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

488 ↗

(On Diff #123810)

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;

763–765 ↗

(On Diff #123810)

This won't cause a crash right?

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

32 ↗

(On Diff #123810)

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

488 ↗

(On Diff #123810)

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

763–765 ↗

(On Diff #123810)

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

735 ↗

(On Diff #123816)

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

735 ↗

(On Diff #123816)

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.

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"
 
 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_

lldb/trunk/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();
 }
 

lldb/trunk/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;

lldb/trunk/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;
   }
 

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