elf-core: Split up parsing code into os-specific functions

[labath]

Summary

We've had a single function responsible for splitting a core segment
into notes, and parsing the notes themselves, bearing in mind variations
between 4 supported OS types. This commit splits that code into 5
pieces:

• (os-independent) code for splitting a segment into individual notes
• per-os function for parsing the notes into thread information

[clayborg]

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

489

Do we need to check anything after parsing a note here to ensure it parsed? Can offset end up not changing and could we get into an infinite loop here? Seems like we should do:

if (!note.Parse(segment, &offset))
  break;

747–749

This won't cause a crash right?

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

32

Why is this needed here? Doesn't seem to be. Can you include only in .cpp file?

[labath]

Address review comments.

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

489

Good point. There was no error checking in the original code, but it looks like there should be...

747–749

Only if the caller does not do anything with the result function (and it that case, it will assert regardless of whether the function returned an error or not).

[krytarowski]

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

481–482

Can we label it as SVR4-style (Linux, FreeBSD, Solaris)? Alternatively move it to other place in order to describe Linux and FreeBSD separately (NetBSD an OpenBSD can be skipped now).

[labath]

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

481–482

Yeah, I was wondering what to do with that comment -- it is so vague it is nearly useless. I agree we should move the core file description to the individual OS's parsing functions. I've written a description of the linux notes. Freebsd ones seem pretty similar, but don't know enough about them to say if the description applies to them as well.

[labath]

Update comments.

[kettenis]

Looks like a good improvement to me.

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"
 
 struct ThreadData;
 
 class ProcessElfCore : public lldb_private::Process {
 public:
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
private:
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, uint32_t>
       VMRangeToPermissions;
 
   lldb::ModuleSP m_core_module_sp;
   lldb_private::FileSpec m_core_file;
   std::string m_dyld_plugin_name;
   DISALLOW_COPY_AND_ASSIGN(ProcessElfCore);
 
-  llvm::Triple::OSType m_os;
-
   // True if m_thread_contexts contains valid entries
-  bool m_thread_data_valid;
+  bool m_thread_data_valid = false;
 
   // Contain thread data read from NOTE segments
   std::vector<ThreadData> m_thread_data;
 
   // AUXV structure found from the NOTE segment
   lldb_private::DataExtractor m_auxv;
 
   // Address ranges found in the core
   VMRangeToFileOffset m_core_aranges;
 
   // Permissions for all ranges
   VMRangeToPermissions m_core_range_infos;
 
   // NT_FILE entries found from the NOTE segment
   std::vector<NT_FILE_Entry> m_nt_file_entries;
 
   // Parse thread(s) data structures(prstatus, prpsinfo) from given NOTE segment
-  lldb_private::Status ParseThreadContextsFromNoteSegment(
+  llvm::Error ParseThreadContextsFromNoteSegment(
       const elf::ELFProgramHeader *segment_header,
       lldb_private::DataExtractor segment_data);
 
   // Returns number of thread contexts stored in the core file
   uint32_t GetNumThreadContexts();
 
   // Parse a contiguous address range of the process from LOAD segment
   lldb::addr_t
   AddAddressRangeFromLoadSegment(const elf::ELFProgramHeader *header);
+
+  llvm::Expected<std::vector<lldb_private::CoreNote>>
+  parseSegment(const lldb_private::DataExtractor &segment);
+  llvm::Error parseFreeBSDNotes(llvm::ArrayRef<lldb_private::CoreNote> notes);
+  llvm::Error parseNetBSDNotes(llvm::ArrayRef<lldb_private::CoreNote> notes);
+  llvm::Error parseOpenBSDNotes(llvm::ArrayRef<lldb_private::CoreNote> notes);
+  llvm::Error parseLinuxNotes(llvm::ArrayRef<lldb_private::CoreNote> notes);
 };
 
 #endif // liblldb_ProcessElfCore_h_

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

 }
 
 //----------------------------------------------------------------------
 // ProcessElfCore constructor
 //----------------------------------------------------------------------
 ProcessElfCore::ProcessElfCore(lldb::TargetSP target_sp,
                                lldb::ListenerSP listener_sp,
                                const FileSpec &core_file)
-    : Process(target_sp, listener_sp), m_core_module_sp(),
-      m_core_file(core_file), m_dyld_plugin_name(),
-      m_os(llvm::Triple::UnknownOS), m_thread_data_valid(false),
-      m_thread_data(), m_core_aranges() {}
+    : Process(target_sp, listener_sp), m_core_file(core_file) {}
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 ProcessElfCore::~ProcessElfCore() {
   Clear();
   // We need to call finalize on the process before destroying ourselves
   // to make sure all of the broadcaster cleanup goes as planned. If we
Status ProcessElfCore::DoLoadCore() {
   for (uint32_t i = 1; i <= num_segments; i++) {
     const elf::ELFProgramHeader *header = core->GetProgramHeaderByIndex(i);
     assert(header != NULL);
 
     DataExtractor data = core->GetSegmentDataByIndex(i);
 
     // Parse thread contexts and auxv structure
     if (header->p_type == llvm::ELF::PT_NOTE) {
-      error = ParseThreadContextsFromNoteSegment(header, data);
-      if (error.Fail())
-        return error;
+      if (llvm::Error error = ParseThreadContextsFromNoteSegment(header, data))
+        return Status(std::move(error));
     }
     // PT_LOAD segments contains address map
     if (header->p_type == llvm::ELF::PT_LOAD) {
       lldb::addr_t last_addr = AddAddressRangeFromLoadSegment(header);
       if (vm_addr > last_addr)
         ranges_are_sorted = false;
       vm_addr = last_addr;
     }
size_t ProcessElfCore::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
   if (zero_fill_size)
     memset(((char *)buf) + bytes_copied, 0, zero_fill_size);
 
   return bytes_copied + zero_fill_size;
 }
 
 void ProcessElfCore::Clear() {
   m_thread_list.Clear();
-  m_os = llvm::Triple::UnknownOS;
 
   SetUnixSignals(std::make_shared<UnixSignals>());
 }
 
 void ProcessElfCore::Initialize() {
   static llvm::once_flag g_once_flag;
 
   llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(), CreateInstance);
   });
 }
 
 lldb::addr_t ProcessElfCore::GetImageInfoAddress() {
   ObjectFile *obj_file = GetTarget().GetExecutableModule()->GetObjectFile();
   Address addr = obj_file->GetImageInfoAddress(&GetTarget());
 
   if (addr.IsValid())
     return addr.GetLoadAddress(&GetTarget());
   return LLDB_INVALID_ADDRESS;
 }
 
 // Parse a FreeBSD NT_PRSTATUS note - see FreeBSD sys/procfs.h for details.
-static void ParseFreeBSDPrStatus(ThreadData &thread_data, DataExtractor &data,
-                                 ArchSpec &arch) {
+static void ParseFreeBSDPrStatus(ThreadData &thread_data,
+                                 const DataExtractor &data,
+                                 const ArchSpec &arch) {
   lldb::offset_t offset = 0;
   bool lp64 = (arch.GetMachine() == llvm::Triple::aarch64 ||
                arch.GetMachine() == llvm::Triple::mips64 ||
                arch.GetMachine() == llvm::Triple::ppc64 ||
                arch.GetMachine() == llvm::Triple::x86_64);
   int pr_version = data.GetU32(&offset);
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
static void ParseFreeBSDPrStatus(ThreadData &thread_data,
   thread_data.tid = data.GetU32(&offset);   // pr_pid
   if (lp64)
     offset += 4;
 
   size_t len = data.GetByteSize() - offset;
   thread_data.gpregset = DataExtractor(data, offset, len);
 }
 
-static void ParseFreeBSDThrMisc(ThreadData &thread_data, DataExtractor &data) {
-  lldb::offset_t offset = 0;
-  thread_data.name = data.GetCStr(&offset, 20);
-}
-
-static void ParseNetBSDProcInfo(ThreadData &thread_data, DataExtractor &data) {
+static void ParseNetBSDProcInfo(ThreadData &thread_data,
+                                const DataExtractor &data) {
   lldb::offset_t offset = 0;
 
   int version = data.GetU32(&offset);
   if (version != 1)
     return;
 
   offset += 4;
   thread_data.signo = data.GetU32(&offset);
 }
 
-static void ParseOpenBSDProcInfo(ThreadData &thread_data, DataExtractor &data) {
+static void ParseOpenBSDProcInfo(ThreadData &thread_data,
+                                 const DataExtractor &data) {
   lldb::offset_t offset = 0;
 
   int version = data.GetU32(&offset);
   if (version != 1)
     return;
 
   offset += 4;
   thread_data.signo = data.GetU32(&offset);
 }
 
-/// Parse Thread context from PT_NOTE segment and store it in the thread list
-/// Notes:
-/// 1) A PT_NOTE segment is composed of one or more NOTE entries.
-/// 2) NOTE Entry contains a standard header followed by variable size data.
-///   (see ELFNote structure)
-/// 3) A Thread Context in a core file usually described by 3 NOTE entries.
-///    a) NT_PRSTATUS - Register context
-///    b) NT_PRPSINFO - Process info(pid..)
-///    c) NT_FPREGSET - Floating point registers
-/// 4) The NOTE entries can be in any order
-/// 5) If a core file contains multiple thread contexts then there is two data
-/// forms
-///    a) Each thread context(2 or more NOTE entries) contained in its own
-///    segment (PT_NOTE)
-///    b) All thread context is stored in a single segment(PT_NOTE).
-///        This case is little tricker since while parsing we have to find where
-///        the
-///        new thread starts. The current implementation marks beginning of
-///        new thread when it finds NT_PRSTATUS or NT_PRPSINFO NOTE entry.
-///    For case (b) there may be either one NT_PRPSINFO per thread, or a single
-///    one that applies to all threads (depending on the platform type).
-Status ProcessElfCore::ParseThreadContextsFromNoteSegment(
-    const elf::ELFProgramHeader *segment_header, DataExtractor segment_data) {
-  assert(segment_header && segment_header->p_type == llvm::ELF::PT_NOTE);
-
+llvm::Expected<std::vector<CoreNote>>
+ProcessElfCore::parseSegment(const DataExtractor &segment) {
   lldb::offset_t offset = 0;
-  std::unique_ptr<ThreadData> thread_data(new ThreadData);
-  bool have_prstatus = false;
-  bool have_prpsinfo = false;
-
-  ArchSpec arch = GetArchitecture();
-  ELFLinuxPrPsInfo prpsinfo;
-  ELFLinuxPrStatus prstatus;
-  ELFLinuxSigInfo siginfo;
-  size_t header_size;
-  size_t len;
-  Status error;
+  std::vector<CoreNote> result;
 
-  // Loop through the NOTE entires in the segment
-  while (offset < segment_header->p_filesz) {
+  while (offset < segment.GetByteSize()) {
     ELFNote note = ELFNote();
-    note.Parse(segment_data, &offset);
+    if (!note.Parse(segment, &offset))
+      return llvm::make_error<llvm::StringError>(
+          "Unable to parse note segment", llvm::inconvertibleErrorCode());
+
+    size_t note_start = offset;
+    size_t note_size = llvm::alignTo(note.n_descsz, 4);
+    DataExtractor note_data(segment, note_start, note_size);
+
+    result.push_back({note, note_data});
+    offset += note_size;
+  }
 
-    // Beginning of new thread
-    if (((note.n_type == LINUX::NT_PRSTATUS ||
-          note.n_type == FREEBSD::NT_PRSTATUS) &&
-         have_prstatus) ||
-        ((note.n_type == LINUX::NT_PRPSINFO ||
-          note.n_type == FREEBSD::NT_PRPSINFO) &&
-         have_prpsinfo)) {
-      assert(thread_data->gpregset.GetByteSize() > 0);
+  return std::move(result);
+}
+
+llvm::Error ProcessElfCore::parseFreeBSDNotes(llvm::ArrayRef<CoreNote> notes) {
+  bool have_prstatus = false;
+  bool have_prpsinfo = false;
+  ThreadData thread_data;
+  for (const auto &note : notes) {
+    if (note.info.n_name != "FreeBSD")
+      continue;
+
+    if ((note.info.n_type == FREEBSD::NT_PRSTATUS && have_prstatus) ||
+        (note.info.n_type == FREEBSD::NT_PRPSINFO && have_prpsinfo)) {
+      assert(thread_data.gpregset.GetByteSize() > 0);
       // Add the new thread to thread list
-      m_thread_data.push_back(*thread_data);
-      *thread_data = ThreadData();
+      m_thread_data.push_back(thread_data);
+      thread_data = ThreadData();
       have_prstatus = false;
       have_prpsinfo = false;
     }
 
-    size_t note_start, note_size;
-    note_start = offset;
-    note_size = llvm::alignTo(note.n_descsz, 4);
-
-    // Store the NOTE information in the current thread
-    DataExtractor note_data(segment_data, note_start, note_size);
-    note_data.SetAddressByteSize(
-        m_core_module_sp->GetArchitecture().GetAddressByteSize());
-    if (note.n_name == "FreeBSD") {
-      m_os = llvm::Triple::FreeBSD;
-      switch (note.n_type) {
-      case FREEBSD::NT_PRSTATUS:
-        have_prstatus = true;
-        ParseFreeBSDPrStatus(*thread_data, note_data, arch);
-        break;
-      case FREEBSD::NT_FPREGSET:
-        thread_data->fpregset = note_data;
-        break;
-      case FREEBSD::NT_PRPSINFO:
-        have_prpsinfo = true;
-        break;
-      case FREEBSD::NT_THRMISC:
-        ParseFreeBSDThrMisc(*thread_data, note_data);
-        break;
-      case FREEBSD::NT_PROCSTAT_AUXV:
-        // FIXME: FreeBSD sticks an int at the beginning of the note
-        m_auxv = DataExtractor(segment_data, note_start + 4, note_size - 4);
-        break;
-      case FREEBSD::NT_PPC_VMX:
-        thread_data->vregset = note_data;
-        break;
-      default:
-        break;
-      }
-    } else if (note.n_name.substr(0, 11) == "NetBSD-CORE") {
-      // NetBSD per-thread information is stored in notes named
-      // "NetBSD-CORE@nnn" so match on the initial part of the string.
-      m_os = llvm::Triple::NetBSD;
-      if (note.n_type == NETBSD::NT_PROCINFO) {
-        ParseNetBSDProcInfo(*thread_data, note_data);
-      } else if (note.n_type == NETBSD::NT_AUXV) {
-        m_auxv = DataExtractor(note_data);
-      } else if (arch.GetMachine() == llvm::Triple::x86_64 &&
-                 note.n_type == NETBSD::NT_AMD64_REGS) {
-        thread_data->gpregset = note_data;
-      } else if (arch.GetMachine() == llvm::Triple::x86_64 &&
-                 note.n_type == NETBSD::NT_AMD64_FPREGS) {
-        thread_data->fpregset = note_data;
-      }
-    } else if (note.n_name.substr(0, 7) == "OpenBSD") {
-      // OpenBSD per-thread information is stored in notes named
-      // "OpenBSD@nnn" so match on the initial part of the string.
-      m_os = llvm::Triple::OpenBSD;
-      switch (note.n_type) {
-      case OPENBSD::NT_PROCINFO:
-        ParseOpenBSDProcInfo(*thread_data, note_data);
-        break;
-      case OPENBSD::NT_AUXV:
-        m_auxv = DataExtractor(note_data);
-        break;
-      case OPENBSD::NT_REGS:
-        thread_data->gpregset = note_data;
-        break;
-      case OPENBSD::NT_FPREGS:
-        thread_data->fpregset = note_data;
-        break;
-      }
-    } else if (note.n_name == "CORE") {
-      switch (note.n_type) {
-      case LINUX::NT_PRSTATUS:
-        have_prstatus = true;
-        error = prstatus.Parse(note_data, arch);
-        if (error.Fail())
-          return error;
-        thread_data->prstatus_sig = 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);
+    switch (note.info.n_type) {
+      ParseFreeBSDPrStatus(thread_data, note.data, GetArchitecture());
+      thread_data.fpregset = note.data;
+      break;
+    case FREEBSD::NT_PPC_VMX:
+      thread_data.vregset = note.data;
+    case FREEBSD::NT_THRMISC: {
+      lldb::offset_t offset = 0;
+      thread_data.name = note.data.GetCStr(&offset, 20);
+    }
+      m_auxv = DataExtractor(note.data, 4, note.data.GetByteSize() - 4);
+  }
+  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) {
+    if (!llvm::StringRef(note.info.n_name).startswith("NetBSD-CORE"))
+      continue;
+
+    if (note.info.n_type == NETBSD::NT_PROCINFO) {
+      ParseNetBSDProcInfo(thread_data, note.data);
+      continue;
+    }
+    if (note.info.n_type == NETBSD::NT_AUXV) {
+      m_auxv = note.data;
+      continue;
+    }
+
+    if (GetArchitecture().GetMachine() == llvm::Triple::x86_64) {
+      switch (note.info.n_type) {
+      case NETBSD::NT_AMD64_REGS:
+        thread_data.gpregset = note.data;
+        break;
+      case NETBSD::NT_AMD64_FPREGS:
+        thread_data.fpregset = note.data;
+        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());
+  }
+  m_thread_data.push_back(thread_data);
+  return llvm::Error::success();
+}
+
+llvm::Error ProcessElfCore::parseOpenBSDNotes(llvm::ArrayRef<CoreNote> notes) {
+  ThreadData thread_data;
+  for (const auto &note : notes) {
+    if (!llvm::StringRef(note.info.n_name).startswith("OpenBSD"))
+      continue;
+
+    switch (note.info.n_type) {
+      ParseOpenBSDProcInfo(thread_data, note.data);
+      m_auxv = note.data;
+      thread_data.gpregset = note.data;
+      thread_data.fpregset = note.data;
+  }
+  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();
+}
+
+/// A description of a linux process usually contains the following NOTE
+/// entries:
+/// - NT_PRPSINFO - General process information like pid, uid, name, ...
+/// - NT_SIGINFO - Information about the signal that terminated the process
+/// - NT_AUXV - Process auxiliary vector
+/// - NT_FILE - Files mapped into memory
+/// 
+/// Additionally, for each thread in the process the core file will contain at
+/// least the NT_PRSTATUS note, containing the thread id and general purpose
+/// registers. It may include additional notes for other register sets (floating
+/// point and vector registers, ...). The tricky part here is that some of these
+/// notes have "CORE" in their owner fields, while other set it to "LINUX".
+llvm::Error ProcessElfCore::parseLinuxNotes(llvm::ArrayRef<CoreNote> notes) {
+  const ArchSpec &arch = GetArchitecture();
+  bool have_prstatus = false;
+  bool have_prpsinfo = false;
+  ThreadData thread_data;
+  for (const auto &note : notes) {
+    if (note.info.n_name != "CORE" && note.info.n_name != "LINUX")
+      continue;
+
+    if ((note.info.n_type == LINUX::NT_PRSTATUS && have_prstatus) ||
+        (note.info.n_type == LINUX::NT_PRPSINFO && have_prpsinfo)) {
+      assert(thread_data.gpregset.GetByteSize() > 0);
+      // Add the new thread to thread list
+      m_thread_data.push_back(thread_data);
+      thread_data = ThreadData();
+      have_prstatus = false;
+      have_prpsinfo = false;
+    }
 
-        if (arch.GetCore() == ArchSpec::eCore_ppc64le_generic)
-          thread_data->regsets.insert(
-              std::make_pair(note.n_type, thread_data->gpregset));
-        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.n_type, note_data));
-        }
-        break;
-      case LINUX::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);
-        break;
-      case LINUX::NT_AUXV:
-        m_auxv = DataExtractor(note_data);
-        break;
-      case LINUX::NT_FILE: {
-        m_nt_file_entries.clear();
-        lldb::offset_t offset = 0;
-        const uint64_t count = note_data.GetAddress(&offset);
-        note_data.GetAddress(&offset); // Skip page size
-        for (uint64_t i = 0; i < count; ++i) {
-          NT_FILE_Entry entry;
-          entry.start = note_data.GetAddress(&offset);
-          entry.end = note_data.GetAddress(&offset);
-          entry.file_ofs = note_data.GetAddress(&offset);
-          m_nt_file_entries.push_back(entry);
-        }
-        for (uint64_t i = 0; i < count; ++i) {
-          const char *path = note_data.GetCStr(&offset);
-          if (path && path[0])
-            m_nt_file_entries[i].path.SetCString(path);
-        }
-      } break;
-      case LINUX::NT_SIGINFO: {
-        error = siginfo.Parse(note_data, arch);
-        if (error.Fail())
-          return error;
-        thread_data->signo = siginfo.si_signo;
-      } break;
-      default:
-        break;
-      }
-    } else if (note.n_name == "LINUX") {
-      switch (note.n_type) {
-      case LINUX::NT_PRXFPREG:
-        thread_data->fpregset = 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.n_type, note_data));
-        break;
-      }
-    }
-
-    offset += note_size;
-  }
+    switch (note.info.n_type) {
+    case LINUX::NT_PRSTATUS: {
+      have_prstatus = true;
+      ELFLinuxPrStatus 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);
+        thread_data.regsets.try_emplace(note.info.n_type, thread_data.gpregset);
+    case LINUX::NT_PRPSINFO: {
+      ELFLinuxPrPsInfo prpsinfo;
+      Status status = prpsinfo.Parse(note.data, arch);
+      if (status.Fail())
+        return status.ToError();
+      thread_data.name = prpsinfo.pr_fname;
+    }
+    case LINUX::NT_SIGINFO: {
+      ELFLinuxSigInfo siginfo;
+      Status status = siginfo.Parse(note.data, arch);
+      if (status.Fail())
+        return status.ToError();
+      thread_data.signo = siginfo.si_signo;
+    }
+      const uint64_t count = note.data.GetAddress(&offset);
+      note.data.GetAddress(&offset); // Skip page size
+        entry.start = note.data.GetAddress(&offset);
+        entry.end = note.data.GetAddress(&offset);
+        entry.file_ofs = note.data.GetAddress(&offset);
+        const char *path = note.data.GetCStr(&offset);
+    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));
+      }
+        thread_data.regsets.insert(std::make_pair(note.info.n_type, note.data));
+      break;
+    case LINUX::NT_PRXFPREG:
+      thread_data.fpregset = note.data;
   // Add last entry in the note section
-  if (thread_data && thread_data->gpregset.GetByteSize() > 0) {
-    m_thread_data.push_back(*thread_data);
-  }
+  if (have_prstatus)
+    m_thread_data.push_back(thread_data);
+  return llvm::Error::success();
 
-  return error;
+/// Parse Thread context from PT_NOTE segment and store it in the thread list
+/// A note segment consists of one or more NOTE entries, but their types and
+/// meaning differ depending on the OS.
+llvm::Error ProcessElfCore::ParseThreadContextsFromNoteSegment(
+    const elf::ELFProgramHeader *segment_header, DataExtractor segment_data) {
+  assert(segment_header && segment_header->p_type == llvm::ELF::PT_NOTE);
+
+  auto notes_or_error = parseSegment(segment_data);
+  if(!notes_or_error)
+    return notes_or_error.takeError();
+  switch (GetArchitecture().GetTriple().getOS()) {
+  case llvm::Triple::FreeBSD:
+    return parseFreeBSDNotes(*notes_or_error);
+  case llvm::Triple::Linux:
+    return parseLinuxNotes(*notes_or_error);
+  case llvm::Triple::NetBSD:
+    return parseNetBSDNotes(*notes_or_error);
+  case llvm::Triple::OpenBSD:
+    return parseOpenBSDNotes(*notes_or_error);
+  default:
+    return llvm::make_error<llvm::StringError>(
+        "Don't know how to parse core file. Unsupported OS.",
+        llvm::inconvertibleErrorCode());
+  }
 }
 
 uint32_t ProcessElfCore::GetNumThreadContexts() {
   if (!m_thread_data_valid)
     DoLoadCore();
   return m_thread_data.size();
 }
 

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

struct ELFLinuxPrStatus {
 
   compat_timeval pr_utime;
   compat_timeval pr_stime;
   compat_timeval pr_cutime;
   compat_timeval pr_cstime;
 
   ELFLinuxPrStatus();
 
-  lldb_private::Status Parse(lldb_private::DataExtractor &data,
-                             lldb_private::ArchSpec &arch);
+  lldb_private::Status Parse(const lldb_private::DataExtractor &data,
+                             const lldb_private::ArchSpec &arch);
 
   // Return the bytesize of the structure
   // 64 bit - just sizeof
   // 32 bit - hardcoded because we are reusing the struct, but some of the
   // members are smaller -
   // so the layout is not the same
-  static size_t GetSize(lldb_private::ArchSpec &arch);
+  static size_t GetSize(const lldb_private::ArchSpec &arch);
 };
 
 static_assert(sizeof(ELFLinuxPrStatus) == 112,
               "sizeof ELFLinuxPrStatus is not correct!");
 
 struct ELFLinuxSigInfo {
   int32_t si_signo;
   int32_t si_code;
   int32_t si_errno;
 
   ELFLinuxSigInfo();
 
-  lldb_private::Status Parse(lldb_private::DataExtractor &data,
+  lldb_private::Status Parse(const lldb_private::DataExtractor &data,
                              const lldb_private::ArchSpec &arch);
 
   // Return the bytesize of the structure
   // 64 bit - just sizeof
   // 32 bit - hardcoded because we are reusing the struct, but some of the
   // members are smaller -
   // so the layout is not the same
   static size_t GetSize(const lldb_private::ArchSpec &arch);
struct ELFLinuxPrPsInfo {
   int32_t pr_ppid;
   int32_t pr_pgrp;
   int32_t pr_sid;
   char pr_fname[16];
   char pr_psargs[80];
 
   ELFLinuxPrPsInfo();
 
-  lldb_private::Status Parse(lldb_private::DataExtractor &data,
-                             lldb_private::ArchSpec &arch);
+  lldb_private::Status Parse(const lldb_private::DataExtractor &data,
+                             const lldb_private::ArchSpec &arch);
 
   // Return the bytesize of the structure
   // 64 bit - just sizeof
   // 32 bit - hardcoded because we are reusing the struct, but some of the
   // members are smaller -
   // so the layout is not the same
-  static size_t GetSize(lldb_private::ArchSpec &arch);
+  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;

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

 
 //----------------------------------------------------------------
 // Parse PRSTATUS from NOTE entry
 //----------------------------------------------------------------
 ELFLinuxPrStatus::ELFLinuxPrStatus() {
   memset(this, 0, sizeof(ELFLinuxPrStatus));
 }
 
-size_t ELFLinuxPrStatus::GetSize(lldb_private::ArchSpec &arch) {
+size_t ELFLinuxPrStatus::GetSize(const lldb_private::ArchSpec &arch) {
   constexpr size_t mips_linux_pr_status_size_o32 = 96;
   constexpr size_t mips_linux_pr_status_size_n32 = 72;
   if (arch.IsMIPS()) {
     std::string abi = arch.GetTargetABI();
     assert(!abi.empty() && "ABI is not set");
     if (!abi.compare("n64"))
       return sizeof(ELFLinuxPrStatus);
     else if (!abi.compare("o32"))
size_t ELFLinuxPrStatus::GetSize(const lldb_private::ArchSpec &arch) {
   case lldb_private::ArchSpec::eCore_x86_32_i386:
   case lldb_private::ArchSpec::eCore_x86_32_i486:
     return 72;
   default:
     return 0;
   }
 }
 
-Status ELFLinuxPrStatus::Parse(DataExtractor &data, ArchSpec &arch) {
+Status ELFLinuxPrStatus::Parse(const DataExtractor &data,
+                               const ArchSpec &arch) {
   Status error;
   if (GetSize(arch) > data.GetByteSize()) {
     error.SetErrorStringWithFormat(
         "NT_PRSTATUS size should be %zu, but the remaining bytes are: %" PRIu64,
         GetSize(arch), data.GetByteSize());
     return error;
   }
 

 
 //----------------------------------------------------------------
 // Parse PRPSINFO from NOTE entry
 //----------------------------------------------------------------
 ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() {
   memset(this, 0, sizeof(ELFLinuxPrPsInfo));
 }
 
-size_t ELFLinuxPrPsInfo::GetSize(lldb_private::ArchSpec &arch) {
+size_t ELFLinuxPrPsInfo::GetSize(const lldb_private::ArchSpec &arch) {
   constexpr size_t mips_linux_pr_psinfo_size_o32_n32 = 128;
   if (arch.IsMIPS()) {
     uint8_t address_byte_size = arch.GetAddressByteSize();
     if (address_byte_size == 8)
       return sizeof(ELFLinuxPrPsInfo);
     return mips_linux_pr_psinfo_size_o32_n32;
   }
   
   switch (arch.GetCore()) {
   case lldb_private::ArchSpec::eCore_s390x_generic:
   case lldb_private::ArchSpec::eCore_x86_64_x86_64:
     return sizeof(ELFLinuxPrPsInfo);
   case lldb_private::ArchSpec::eCore_x86_32_i386:
   case lldb_private::ArchSpec::eCore_x86_32_i486:
     return 124;
   default:
     return 0;
   }
 }
 
-Status ELFLinuxPrPsInfo::Parse(DataExtractor &data, ArchSpec &arch) {
+Status ELFLinuxPrPsInfo::Parse(const DataExtractor &data,
+                               const ArchSpec &arch) {
   Status error;
   ByteOrder byteorder = data.GetByteOrder();
   if (GetSize(arch) > data.GetByteSize()) {
     error.SetErrorStringWithFormat(
         "NT_PRPSINFO size should be %zu, but the remaining bytes are: %" PRIu64,
         GetSize(arch), data.GetByteSize());
     return error;
   }
size_t ELFLinuxSigInfo::GetSize(const lldb_private::ArchSpec &arch) {
   case lldb_private::ArchSpec::eCore_x86_32_i386:
   case lldb_private::ArchSpec::eCore_x86_32_i486:
     return 12;
   default:
     return 0;
   }
 }
 
-Status ELFLinuxSigInfo::Parse(DataExtractor &data, const ArchSpec &arch) {
+Status ELFLinuxSigInfo::Parse(const DataExtractor &data, const ArchSpec &arch) {
   Status error;
   if (GetSize(arch) > data.GetByteSize()) {
     error.SetErrorStringWithFormat(
         "NT_SIGINFO size should be %zu, but the remaining bytes are: %" PRIu64,
         GetSize(arch), data.GetByteSize());
     return error;
   }
 

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,
enum {
   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