[lldb] [Process] Add proper support for NetBSD core files with threads

[mgorny]

Summary

Improve the support for processing NetBSD cores. Fix reading process
identifier, thread information and associating the terminating signal
with the correct thread.

Includes test cases for single-threaded program receiving SIGSEGV,
and two dual-threaded programs: one where thread receives the signal,
and the other one when the whole process is signalled.

[krytarowski]

Demo:

http://netbsd.org/~kamil/lldb/firefox-core.typescript

Replay:

script -p ./firefox-core.typescript

BSD script(1) is incompatible with the GNU one, so I prepared a quick port to Linux:

http://netbsd.org/~kamil/lldb/nbscript.c

gcc nbscript.c -lutil -o nbscript

[labath]

A test would infinitely times more valuable then a demo script. What is the tiniest core file you can produce on NetBSD? (on linux we've gotten them down to about 20K) Then we could check that in and write a test for it...

[krytarowski]

In D32149#731887, @labath wrote:

A test would infinitely times more valuable then a demo script. What is the tiniest core file you can produce on NetBSD? (on linux we've gotten them down to about 20K) Then we could check that in and write a test for it...

This is something I wanted to bring to the dev mailing list.

I wanted to prepare at least three tests, if possible four:

• one thread (if possible two variations: signal to one particular thread + signal to all threads)
• multiple threads (signal to one particular thread + signal to all threads)

And this in combination of all supported targets (x86_64, i386, etc).

Emitting SIGABRT for such program gives core of size 97kilobytes:

int main(){for(;;);}

I will write assembly programs for the above cases, without libc.

[kettenis]

Generally looks reasonable to me. A few comments inline.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1389

By making this change you risk losing recognition of "normal" NetBSD ELF files, i.e. executables and shared libraries.

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

604

A bit strange to call something both generic and specific...

I think some of these note types originated on SVR4/Solaris, but I'm not sure how much Linux deviated from that design through the years.

856

Wouldn't it make sense to move the parsing of the LWP ID before the switch. Otherwise you'll have to duplicate the code for every NetBSD architecture you'll add.

[kettenis]

In D32149#731887, @labath wrote:

A test would infinitely times more valuable then a demo script. What is the tiniest core file you can produce on NetBSD? (on linux we've gotten them down to about 20K) Then we could check that in and write a test for it...

The smalles core dumps I managed to create for OpenBSD so far are a bit over 4M.

[krytarowski]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1389

Hmm, do you mean these notes:

$ readelf -n /bin/cat                                                                                                                                 

Displaying notes found at file offset 0x00000214 with length 0x00000018:
  Owner                 Data size	Description
  NetBSD		0x00000004	IDENT 799005900 (7.99.59)

Displaying notes found at file offset 0x0000022c with length 0x00000014:
  Owner                 Data size	Description
  NetBSD		0x00000004	PaX <>

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

604

Can we call it: Type1 core (as of now: NetBSD) and Type2 core (Linux, Android, FreeBSD, OpenBSD)?

I don't care which would be 1 and which 2.

856

Sounds good.

[kettenis]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1389

In particular the first one of these. On OpenBSD I just have a generic check on the name which catches both these and the core file notes. But on NetBSD those use different names.

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

604

I'd just drop word "specific" from the comment. And OpenBSD will obviously be handled in a similar way as NetBSD in the near future.

[krytarowski]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1389

I will test it and add switch to support both types of ELF files: core(5) and executables.

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

604

Assuming that NetBSD and OpenBSD will share the same function - we can go pickup appropriate name now.

As far as I can tell FreeBSD shares similar concept to Linux.

A thread specific data is defined by multiplication of the following notes:

FreeBSD       0x000000e0      NT_PRSTATUS (prstatus structure)
FreeBSD       0x00000200      NT_FPREGSET (floating point registers)
FreeBSD       0x00000018      NT_THRMISC (thrmisc structure)

[labath]

In D32149#731920, @krytarowski wrote:

In D32149#731887, @labath wrote:

A test would infinitely times more valuable then a demo script. What is the tiniest core file you can produce on NetBSD? (on linux we've gotten them down to about 20K) Then we could check that in and write a test for it...

This is something I wanted to bring to the dev mailing list.

I wanted to prepare at least three tests, if possible four:

• one thread (if possible two variations: signal to one particular thread + signal to all threads)
• multiple threads (signal to one particular thread + signal to all threads)

And this in combination of all supported targets (x86_64, i386, etc).

Emitting SIGABRT for such program gives core of size 97kilobytes:

int main(){for(;;);}

I will write assembly programs for the above cases, without libc.

Cool, I am looking forward to the results.

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

836

How about StringRef name = note.n_name;

844

Then this can be

else if (name.consume_front("NetBSD-CORE@")) {
  ...
  if (name.getAsInteger(0, tid))
    error...

889

for (auto &data: m_thread_data) data.signo = signo seems shorter, more understandable, and consistent with other usages in this file.

897

This could also be a range-based for.

[krytarowski]

Fix handling executable and shared library triple detection.

Apply changes from review.

Update revision summary.

[krytarowski]

ping?

[joerg]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

55

Not your fault, but is there a reason why this are all pointers to strings and not just const char[] ?

303

Unrelated cosmetic change.

412

Unrelated cosmetic change.

776

Dito.

1488

Unrelated.

2412

Unrelated.

2436

Unrelated.

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

378

Unrelated.

462–493

Either sort them by value or by name, but not randomly

577

Can you define a constant for the offset here below instead of a magic number?

726

Unrelated.

885

Typo

895

Move the else to the } and the comment after the {

[krytarowski]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

303

I let clang-format to go and alter minor things. I can run clang-format over original files - commit, and add my diff again.

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

462–493

I will split this enum{} into two enums.

577

I will try to get something to define aliases for these magic numbers.

885

OK

895

OK

[labath]

In D32149#738250, @krytarowski wrote:

ping?

Sorry, I wasn't responding partially because I was waiting to see how the discussion on https://reviews.llvm.org/D32434 settles, as I think it may have effect on the test strategy. I'll write more tomorrow. :)

[krytarowski]

In D32149#739727, @labath wrote:

In D32149#738250, @krytarowski wrote:

ping?

Sorry, I wasn't responding partially because I was waiting to see how the discussion on https://reviews.llvm.org/D32434 settles, as I think it may have effect on the test strategy. I'll write more tomorrow. :)

Thanks for working on it. I will upload soon changes to address noted by Joerg.

[krytarowski]

Strip non-functional style improvements in unrelated code-parts.

Apply changes to address comments from Joerg.

[krytarowski]

Remove another unrelated style improvement.

[krytarowski]

Rebase to HEAD.
Apply "Error" -> "Status" rename.

[krytarowski]

Can we go with this change?

[labath]

What was your decision on the core files? I was under the impression you were gonna add the zip files as well. If so, then they should go in at the same time.

[krytarowski]

In D32149#763008, @labath wrote:

What was your decision on the core files? I was under the impression you were gonna add the zip files as well. If so, then they should go in at the same time.

In the same commit? If so I will try to amend the patch.

[labath]

Affirmative. Tests should go in together with the feature they are testing.

[krytarowski]

Suspended, I need to resurrect tracing of 1 thread and fix kernel bugs for multiple threads first.

[mgorny]

I've attempted to rebase Kamil's patch against the current sources. Please note that this is not the final version; I'll add a test case and PID reading later.

[mgorny]

Updated to read PID and make unknown notes non-fatal.

[mgorny]

Added two tests, more pending. Sadly, I wasn't able to reuse even the test cases since -nostdlib doesn't really work on NetBSD (resulting executables are not recognized as valid executables).

[mgorny]

I've added one more test case, and added stop reason/signal checking for both threads. I think it's ready for review now.

[krytarowski]

Looks good to me.

[labath]

The code looks good, though I think we should really start figuring out how to write elf core tests without checking in binaries.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 using namespace llvm::ELF;
 
 namespace {
 
 // ELF note owner definitions
 const char *const LLDB_NT_OWNER_FREEBSD = "FreeBSD";
 const char *const LLDB_NT_OWNER_GNU = "GNU";
 const char *const LLDB_NT_OWNER_NETBSD = "NetBSD";
+const char *const LLDB_NT_OWNER_NETBSDCORE = "NetBSD-CORE";
 const char *const LLDB_NT_OWNER_OPENBSD = "OpenBSD";
 const char *const LLDB_NT_OWNER_CSR = "csr";
 const char *const LLDB_NT_OWNER_ANDROID = "Android";
 const char *const LLDB_NT_OWNER_CORE = "CORE";
 const char *const LLDB_NT_OWNER_LINUX = "LINUX";
 
 // ELF note type definitions
 const elf_word LLDB_NT_FREEBSD_ABI_TAG = 0x01;
 const elf_word LLDB_NT_FREEBSD_ABI_SIZE = 4;
 
 const elf_word LLDB_NT_GNU_ABI_TAG = 0x01;
 const elf_word LLDB_NT_GNU_ABI_SIZE = 16;
 
 const elf_word LLDB_NT_GNU_BUILD_ID_TAG = 0x03;
 
-const elf_word LLDB_NT_NETBSD_ABI_TAG = 0x01;
-const elf_word LLDB_NT_NETBSD_ABI_SIZE = 4;
+const elf_word LLDB_NT_NETBSD_NT_NETBSD_IDENT_TAG = 1;
+const elf_word LLDB_NT_NETBSD_NT_NETBSD_IDENT_DESCSZ = 4;
+const elf_word LLDB_NT_NETBSD_NT_NETBSD_IDENT_NAMESZ = 7;
+const elf_word LLDB_NT_NETBSD_NT_PROCINFO = 1;
 
 // GNU ABI note OS constants
 const elf_word LLDB_NT_GNU_ABI_OS_LINUX = 0x00;
 const elf_word LLDB_NT_GNU_ABI_OS_HURD = 0x01;
 const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02;
 
 // LLDB_NT_OWNER_CORE and LLDB_NT_OWNER_LINUX note contants
 #define NT_PRSTATUS 1
static uint32_t mipsVariantFromElfFlags (const elf::ELFHeader &header) {
   const uint32_t mips_arch = header.e_flags & llvm::ELF::EF_MIPS_ARCH;
   uint32_t endian = header.e_ident[EI_DATA];
   uint32_t arch_variant = ArchSpec::eMIPSSubType_unknown;
   uint32_t fileclass = header.e_ident[EI_CLASS];
 
   // If there aren't any elf flags available (e.g core elf file) then return default 
   // 32 or 64 bit arch (without any architecture revision) based on object file's class.
   if (header.e_type == ET_CORE) {
     switch (fileclass) {
     case llvm::ELF::ELFCLASS32:
       return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el
                                      : ArchSpec::eMIPSSubType_mips32;
     case llvm::ELF::ELFCLASS64:
       return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el
                                      : ArchSpec::eMIPSSubType_mips64;
     default:
       return arch_variant;
ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp,
                                           DataBufferSP &data_sp,
                                           lldb::offset_t data_offset,
                                           const lldb_private::FileSpec *file,
                                           lldb::offset_t file_offset,
                                           lldb::offset_t length) {
   if (!data_sp) {
     data_sp =
         DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset);
     if (!data_sp)
       return nullptr;
     data_offset = 0;
   }
 
   assert(data_sp);
 
   if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
     return nullptr;
if (header.Parse(data, &header_offset)) {
                 }
 
                 core_notes_crc =
                     CalculateELFNotesSegmentsCRC32(program_headers, data);
               } else {
                 // Need to map entire file into memory to calculate the crc.
                 data_sp = DataBufferLLVM::CreateSliceFromPath(file.GetPath(), -1,
                                                          file_offset);
                 if (data_sp) {
                   data.SetData(data_sp);
                   gnu_debuglink_crc = calc_gnu_debuglink_crc32(
                       data.GetDataStart(), data.GetByteSize());
                 }
               }
             }
             if (gnu_debuglink_crc) {
               // Use 4 bytes of crc from the .gnu_debuglink section.
else if (note.n_name == LLDB_NT_OWNER_GNU) {
         }
         break;
       }
       if (arch_spec.IsMIPS() &&
           arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
         // The note.n_name == LLDB_NT_OWNER_GNU is valid for Linux platform
         arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
     }
-    // Process NetBSD ELF notes.
+    // Process NetBSD ELF executables and shared libraries
     else if ((note.n_name == LLDB_NT_OWNER_NETBSD) &&
-             (note.n_type == LLDB_NT_NETBSD_ABI_TAG) &&
-             (note.n_descsz == LLDB_NT_NETBSD_ABI_SIZE)) {
-      // Pull out the min version info.
+             (note.n_type == LLDB_NT_NETBSD_NT_NETBSD_IDENT_TAG) &&
+             (note.n_descsz == LLDB_NT_NETBSD_NT_NETBSD_IDENT_DESCSZ) &&
+             (note.n_namesz == LLDB_NT_NETBSD_NT_NETBSD_IDENT_NAMESZ)) {
+      // Pull out the version info
       uint32_t version_info;
       if (data.GetU32(&offset, &version_info, 1) == nullptr) {
         error.SetErrorString("failed to read NetBSD ABI note payload");
         return error;
       }
-
+      // Convert the version info into a major/minor/patch number.
+      //     #define __NetBSD_Version__ MMmmrrpp00
+      //
+      //     M = major version
+      //     m = minor version; a minor number of 99 indicates current.
+      //     r = 0 (since NetBSD 3.0 not used)
+      //     p = patchlevel
+      const uint32_t version_major = version_info / 100000000;
+      const uint32_t version_minor = (version_info % 100000000) / 1000000;
+      const uint32_t version_patch = (version_info % 10000) / 100;
+      char os_name[32];
+      snprintf(os_name, sizeof(os_name),
+               "netbsd%" PRIu32 ".%" PRIu32 ".%" PRIu32, version_major,
+               version_minor, version_patch);
+      // Set the elf OS version to NetBSD.  Also clear the vendor.
+      arch_spec.GetTriple().setOSName(os_name);
+      arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
+    }
+    // Process NetBSD ELF core(5) notes
+    else if ((note.n_name == LLDB_NT_OWNER_NETBSDCORE) &&
+             (note.n_type == LLDB_NT_NETBSD_NT_PROCINFO)) {
       // Set the elf OS version to NetBSD.  Also clear the vendor.
       arch_spec.GetTriple().setOS(llvm::Triple::OSType::NetBSD);
       arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
-
-      if (log)
-        log->Printf(
-            "ObjectFileELF::%s detected NetBSD, min version constant %" PRIu32,
-            __FUNCTION__, version_info);
     }
     // Process OpenBSD ELF notes.
     else if (note.n_name == LLDB_NT_OWNER_OPENBSD) {
       // Set the elf OS version to OpenBSD.  Also clear the vendor.
       arch_spec.GetTriple().setOS(llvm::Triple::OSType::OpenBSD);
       arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
     }
     // Process CSR kalimba notes
else if ((note.n_type == LLDB_NT_GNU_ABI_TAG) &&
           if (cstr == nullptr) {
             error.SetErrorStringWithFormat("ObjectFileELF::%s trying to read "
                                            "at an offset after the end "
                                            "(GetCStr returned nullptr)",
                                            __FUNCTION__);
             return error;
           }
           llvm::StringRef path(cstr);
           if (path.contains("/lib/x86_64-linux-gnu") || path.contains("/lib/i386-linux-gnu")) {
             arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
             break;
           }
         }
         if (arch_spec.IsMIPS() &&
             arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
           // In case of MIPSR6, the LLDB_NT_OWNER_GNU note is missing
           // for some cases (e.g. compile with -nostdlib)
for (i = 0; i < num_symbols; ++i) {
     // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB
     // symbols. See above for
     // more details.
     uint64_t symbol_value = symbol.st_value + symbol_value_offset;
 
     if (symbol_section_sp == nullptr && section_idx == SHN_ABS &&
         symbol.st_size != 0) {
       // We don't have a section for a symbol with non-zero size. Create a new
       // section for it

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

 private:
   struct NT_FILE_Entry {
     lldb::addr_t start;
     lldb::addr_t end;
     lldb::addr_t file_ofs;
     lldb_private::ConstString path;
   };
 
+  // Parse thread(s) data structuresNetBSD(prstatus, prpsinfo) from given NOTE
+  // segment
+  lldb_private::Status ParseThreadContextsFromNoteSegmentNetBSD(
+      const elf::ELFProgramHeader *segment_header,
+      lldb_private::DataExtractor segment_data);
+
+  // Parse thread(s) data structuresGeneric(prstatus, prpsinfo) from given NOTE
+  // segment
+  lldb_private::Status ParseThreadContextsFromNoteSegmentGeneric(
+      const elf::ELFProgramHeader *segment_header,
+      lldb_private::DataExtractor segment_data);
+
   //------------------------------------------------------------------
   // For ProcessElfCore only
   //------------------------------------------------------------------
   typedef lldb_private::Range<lldb::addr_t, lldb::addr_t> FileRange;
   typedef lldb_private::RangeDataArray<lldb::addr_t, lldb::addr_t, FileRange, 1>
       VMRangeToFileOffset;
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, uint32_t>
       VMRangeToPermissions;

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

 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Threading.h"
 
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 
 // Project includes
 #include "ProcessElfCore.h"
size_t ProcessElfCore::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
   const lldb::addr_t file_end = address_range->data.GetRangeEnd();
   size_t bytes_to_read = size; // Number of bytes to read from the core file
   size_t bytes_copied = 0;   // Number of bytes actually read from the core file
   size_t zero_fill_size = 0; // Padding
   lldb::addr_t bytes_left =
       0; // Number of bytes available in the core file from the given address
 
   // Don't proceed if core file doesn't contain the actual data for this address range.
   if (file_start == file_end)
     return 0;
 
   // Figure out how many on-disk bytes remain in this segment
   // starting at the given offset
   if (file_end > file_start + offset)
     bytes_left = file_end - (file_start + offset);
 
   // Figure out how many bytes we need to zero-fill if we are
enum {
   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 };
+enum { NT_PROCINFO = 1, NT_AUXV = 2 };
+
+/* Size in bytes */
+enum { NT_PROCINFO_SIZE = 160 };
+
+/* Size in bytes */
+enum {
+  NT_PROCINFO_CPI_VERSION_SIZE = 4,
+  NT_PROCINFO_CPI_CPISIZE_SIZE = 4,
+  NT_PROCINFO_CPI_SIGNO_SIZE = 4,
+  NT_PROCINFO_CPI_SIGCODE_SIZE = 4,
+  NT_PROCINFO_CPI_SIGPEND_SIZE = 16,
+  NT_PROCINFO_CPI_SIGMASK_SIZE = 16,
+  NT_PROCINFO_CPI_SIGIGNORE_SIZE = 16,
+  NT_PROCINFO_CPI_SIGCATCH_SIZE = 16,
+  NT_PROCINFO_CPI_PID_SIZE = 4,
+  NT_PROCINFO_CPI_PPID_SIZE = 4,
+  NT_PROCINFO_CPI_PGRP_SIZE = 4,
+  NT_PROCINFO_CPI_SID_SIZE = 4,
+  NT_PROCINFO_CPI_RUID_SIZE = 4,
+  NT_PROCINFO_CPI_EUID_SIZE = 4,
+  NT_PROCINFO_CPI_SVUID_SIZE = 4,
+  NT_PROCINFO_CPI_RGID_SIZE = 4,
+  NT_PROCINFO_CPI_EGID_SIZE = 4,
+  NT_PROCINFO_CPI_SVGID_SIZE = 4,
+  NT_PROCINFO_CPI_NLWPS_SIZE = 4,
+  NT_PROCINFO_CPI_NAME_SIZE = 32,
+  NT_PROCINFO_CPI_SIGLWP_SIZE = 4,
+};
+
+namespace AMD64 {
+enum { NT_REGS = 33, NT_FPREGS = 35 };
 }
 
+} // namespace NETBSD
+
 // Parse a FreeBSD NT_PRSTATUS note - see FreeBSD sys/procfs.h for details.
 static void ParseFreeBSDPrStatus(ThreadData &thread_data, DataExtractor &data,
                                  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);
static void ParseFreeBSDPrStatus(ThreadData &thread_data, DataExtractor &data,
   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 Status ParseNetBSDProcInfo(DataExtractor &data, uint32_t &cpi_nlwps,
+                                 uint32_t &cpi_signo, uint32_t &cpi_siglwp) {
   lldb::offset_t offset = 0;
 
-  int version = data.GetU32(&offset);
+  uint32_t version = data.GetU32(&offset);
   if (version != 1)
-    return;
+    return Status(
+        "Error parsing NetBSD core(5) notes: Unsupported procinfo version");
 
-  offset += 4;
-  thread_data.signo = data.GetU32(&offset);
+  uint32_t cpisize = data.GetU32(&offset);
+  if (cpisize != NETBSD::NT_PROCINFO_SIZE)
+    return Status(
+        "Error parsing NetBSD core(5) notes: Unsupported procinfo size");
+
+  cpi_signo = data.GetU32(&offset); /* killing signal */
+
+  offset += NETBSD::NT_PROCINFO_CPI_SIGCODE_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_SIGPEND_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_SIGMASK_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_SIGIGNORE_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_SIGCATCH_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_PID_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_PPID_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_PGRP_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_SID_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_RUID_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_EUID_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_SVUID_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_RGID_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_EGID_SIZE;
+  offset += NETBSD::NT_PROCINFO_CPI_SVGID_SIZE;
+  cpi_nlwps = data.GetU32(&offset); /* number of LWPs */
+
+  offset += NETBSD::NT_PROCINFO_CPI_NAME_SIZE;
+  cpi_siglwp = data.GetU32(&offset); /* LWP target of killing signal */
+
+  return Status();
 }
 
 static void ParseOpenBSDProcInfo(ThreadData &thread_data, 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.
+Status ProcessElfCore::ParseThreadContextsFromNoteSegment(
+    const elf::ELFProgramHeader *segment_header, DataExtractor segment_data) {
+
+  assert(segment_header && segment_header->p_type == llvm::ELF::PT_NOTE);
+
+  switch (GetArchitecture().GetTriple().getOS()) {
+  case llvm::Triple::NetBSD:
+    return ParseThreadContextsFromNoteSegmentNetBSD(segment_header,
+                                                    segment_data);
+  default:
+    return ParseThreadContextsFromNoteSegmentGeneric(segment_header,
+                                                     segment_data);
+  }
+}
+
+/// Generic (Linux, Android, FreeBSD, ...) Thread context from PT_NOTE segment
+/// 1) 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
+/// 2) The NOTE entries can be in any order
+/// 3) 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(
+Status ProcessElfCore::ParseThreadContextsFromNoteSegmentGeneric(
     const elf::ELFProgramHeader *segment_header, DataExtractor segment_data) {
+
   assert(segment_header && segment_header->p_type == llvm::ELF::PT_NOTE);
 
   lldb::offset_t offset = 0;
   std::unique_ptr<ThreadData> thread_data(new ThreadData);
   bool have_prstatus = false;
   bool have_prpsinfo = false;
 
   ArchSpec arch = GetArchitecture();
if (note.n_name == "FreeBSD") {
         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 NT_OPENBSD_PROCINFO:
         ParseOpenBSDProcInfo(*thread_data, note_data);
         break;
if (note.n_name == "FreeBSD") {
         thread_data->gpregset = DataExtractor(note_data, header_size, len);
         break;
       case NT_FPREGSET:
         // In a i386 core file NT_FPREGSET is present, but it's not the result
         // of the FXSAVE instruction like in 64 bit files.
         // The result from FXSAVE is in NT_PRXFPREG for i386 core files
         if (arch.GetCore() == ArchSpec::eCore_x86_64_x86_64)
           thread_data->fpregset = note_data;
-        else if(arch.IsMIPS())
+        else if (arch.IsMIPS())
           thread_data->fpregset = note_data;
         break;
       case NT_PRPSINFO:
         have_prpsinfo = true;
         error = prpsinfo.Parse(note_data, arch);
         if (error.Fail())
           return error;
         thread_data->name = prpsinfo.pr_fname;
Status ProcessElfCore::ParseThreadContextsFromNoteSegmentGeneric(
   // Add last entry in the note section
   if (thread_data && thread_data->gpregset.GetByteSize() > 0) {
     m_thread_data.push_back(*thread_data);
   }
 
   return error;
 }
 
+/// NetBSD specific Thread context from PT_NOTE segment
+///
+/// NetBSD ELF core files use notes to provide information about
+/// the process's state.  The note name is "NetBSD-CORE" for
+/// information that is global to the process, and "NetBSD-CORE@nn",
+/// where "nn" is the lwpid of the LWP that the information belongs
+/// to (such as register state).
+///
+/// NetBSD uses the following note identifiers:
+///
+///      ELF_NOTE_NETBSD_CORE_PROCINFO (value 1)
+///             Note is a "netbsd_elfcore_procinfo" structure.
+///      ELF_NOTE_NETBSD_CORE_AUXV     (value 2; since NetBSD 8.0)
+///             Note is an array of AuxInfo structures.
+///
+/// NetBSD also uses ptrace(2) request numbers (the ones that exist in
+/// machine-dependent space) to identify register info notes.  The
+/// info in such notes is in the same format that ptrace(2) would
+/// export that information.
+///
+/// For more information see /usr/include/sys/exec_elf.h
+///
+Status ProcessElfCore::ParseThreadContextsFromNoteSegmentNetBSD(
+    const elf::ELFProgramHeader *segment_header, DataExtractor segment_data) {
+
+  assert(segment_header && segment_header->p_type == llvm::ELF::PT_NOTE);
+
+  lldb::offset_t offset = 0;
+  ArchSpec arch = GetArchitecture();
+  m_os = llvm::Triple::NetBSD;
+
+  /*
+   * To be extracted from struct netbsd_elfcore_procinfo
+   * Used to sanity check of the LWPs of the process
+   */
+  uint32_t nlwps = 0;
+  uint32_t signo;  /* killing signal */
+  uint32_t siglwp; /* LWP target of killing signal */
+
+  while (offset < segment_header->p_filesz) {
+    ELFNote note = ELFNote();
+    note.Parse(segment_data, &offset);
+
+    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());
+
+    llvm::StringRef name = note.n_name;
+
+    if (name == "NetBSD-CORE") {
+      if (note.n_type == NETBSD::NT_PROCINFO) {
+        Status error = ParseNetBSDProcInfo(note_data, nlwps, signo, siglwp);
+        if (error.Fail())
+          return error;
+      } else if (note.n_type == NETBSD::NT_AUXV) {
+        m_auxv = DataExtractor(note_data);
+      }
+    } else if (name.consume_front("NetBSD-CORE@")) {
+      lldb::tid_t tid;
+      if (name.getAsInteger(10, tid))
+        return Status("Error parsing NetBSD core(5) notes: Cannot convert "
+                     "LWP ID to integer");
+
+      switch (arch.GetMachine()) {
+      case llvm::Triple::x86_64: {
+        /* Assume order PT_GETREGS, PT_GETFPREGS */
+        if (note.n_type == NETBSD::AMD64::NT_REGS) {
+          m_thread_data.push_back(ThreadData());
+          m_thread_data.back().gpregset = note_data;
+          m_thread_data.back().tid = tid;
+        } else if (note.n_type == NETBSD::AMD64::NT_FPREGS) {
+          if (m_thread_data.empty() || tid != m_thread_data.back().tid)
+            return Status("Error parsing NetBSD core(5) notes: Unexpected order "
+                         "of NOTEs PT_GETFPREG before PT_GETREG");
+          m_thread_data.back().fpregset = note_data;
+        } else {
+          return Status(
+              "Error parsing NetBSD core(5) notes: Unsupported AMD64 NOTE");
+        }
+      } break;
+      default:
+        return Status(
+            "Error parsing NetBSD core(5) notes: Unsupported architecture");
+      }
+    } else {
+      return Status("Error parsing NetBSD core(5) notes: Unrecognized note");
+    }
+
+    offset += note_size;
+  }
+
+  if (m_thread_data.empty())
+    return Status("Error parsing NetBSD core(5) notes: No threads information "
+                 "specified in notes");
+
+  if (m_thread_data.size() != nlwps)
+    return Status("Error parsing NetBSD core(5) notes: Mismatch between the "
+                 "number of LWPs in netbsd_elfcore_procinfo and the number of "
+                 "LWPs specified by MD notes");
+
+  /* The whole process signal */
+  if (siglwp == 0) {
+    for (auto &data : m_thread_data)
+      data.signo = signo;
+  }
+  /* Signal destinated for a particular LWP */
+  else {
+    bool passed = false;
+
+    for (auto &data : m_thread_data) {
+      if (data.tid == siglwp) {
+        data.signo = signo;
+        passed = true;
+        break;
+      }
+    }
+
+    if (!passed)
+      return Status(
+          "Error parsing NetBSD core(5) notes: Signal passed to unknown LWP");
+  }
+
+  return Status();
+}
+
 uint32_t ProcessElfCore::GetNumThreadContexts() {
   if (!m_thread_data_valid)
     DoLoadCore();
   return m_thread_data.size();
 }
 
 ArchSpec ProcessElfCore::GetArchitecture() {
   ObjectFileELF *core_file =