[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

563

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.

815

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

563

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.

815

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

563

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

563

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

795

How about StringRef name = note.n_name;

803

Then this can be

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

848

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

856

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[] ?

302

Unrelated cosmetic change.

412

Unrelated cosmetic change.

775

Dito.

1488

Unrelated.

3042

Unrelated.

3066

Unrelated.

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

378

Unrelated.

463

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

523

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

685

Unrelated.

844

Typo

854

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

[krytarowski]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

302

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

463

I will split this enum{} into two enums.

523

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

844

OK

854

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
case 20:
     kal_arch_variant = llvm::Triple::KalimbaSubArch_v5;
     break;
   default:
     break;
   }
   return kal_arch_variant;
 }
 
-static uint32_t mipsVariantFromElfFlags (const elf::ELFHeader &header) {
+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 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;

 
 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);
+    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;
 
   const uint8_t *magic = data_sp->GetBytes() + data_offset;
   if (!ELFHeader::MagicBytesMatch(magic))
     return nullptr;
 
   // Update the data to contain the entire file if it doesn't already
   if (data_sp->GetByteSize() < length) {
-    data_sp =
-        DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset);
+    data_sp = DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length,
+                                                  file_offset);
     if (!data_sp)
       return nullptr;
     data_offset = 0;
     magic = data_sp->GetBytes();
   }
 
   unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
   if (address_size == 4 || address_size == 8) {
if (header.Parse(data, &header_offset)) {
           }
 
           // In case there is header extension in the section #0, the header
           // we parsed above could have sentinel values for e_phnum, e_shnum,
           // and e_shstrndx.  In this case we need to reparse the header
           // with a bigger data source to get the actual values.
           size_t section_header_end = header.e_shoff + header.e_shentsize;
           if (header.HasHeaderExtension() &&
               section_header_end > data_sp->GetByteSize()) {
             data_sp = DataBufferLLVM::CreateSliceFromPath(
                 file.GetPath(), section_header_end, file_offset);
             if (data_sp) {
               data.SetData(data_sp);
               lldb::offset_t header_offset = data_offset;
               header.Parse(data, &header_offset);
             }
           }
if (header.Parse(data, &header_offset)) {
                   if (data_sp)
                     data.SetData(data_sp);
                 }
 
                 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);
+                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) {
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")) {
+          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)
           // Hence set OS to Linux
-          arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 
+          arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
       }
     }
 
     // Calculate the offset of the next note just in case "offset" has been used
     // to poke at the contents of the note data
     offset = note_offset + note.GetByteSize();
   }
 
size_t ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl &section_headers,
   // Only initialize the arch_spec to okay defaults if they're not already set.
   // We'll refine this with note data as we parse the notes.
   if (arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) {
     llvm::Triple::OSType ostype;
     llvm::Triple::OSType spec_ostype;
     const uint32_t sub_type = subTypeFromElfHeader(header);
     arch_spec.SetArchitecture(eArchTypeELF, header.e_machine, sub_type,
                               header.e_ident[EI_OSABI]);
-    
     // Validate if it is ok to remove GetOsFromOSABI.
     // Note, that now the OS is determined based on EI_OSABI flag and
     // the info extracted from ELF notes (see RefineModuleDetailsFromNote).
     // However in some cases that still might be not enough: for example
     // a shared library might not have any notes at all
     // and have EI_OSABI flag set to System V,
     // as result the OS will be set to UnknownOS.
     GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
if (arch.IsValid()) {
        * need
        * for special mode-control register. However, apart from .debug_line,
        * none of
        * the ELF/DWARF sections set the ISA bit (for symbol or section). Use
        * st_other
        * flag to check whether the symbol is microMIPS and then set the address
        * class
        * accordingly.
        */
       const llvm::Triple::ArchType llvm_arch = arch.GetMachine();
       if (llvm_arch == llvm::Triple::mips ||
           llvm_arch == llvm::Triple::mipsel ||
           llvm_arch == llvm::Triple::mips64 ||
           llvm_arch == llvm::Triple::mips64el) {
         if (IS_MICROMIPS(symbol.st_other))
           m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA;
         else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) {
void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table,
   // symbol table after
   // we colleced all symbols we want to add. This is neccessary because adding a
   // new symbol
   // invalidates the internal index of the symtab what causing the next lookup
   // to be slow because
   // it have to recalculate the index first.
   std::vector<Symbol> new_symbols;
 
-  eh_frame->ForEachFDEEntries([this, symbol_table, section_list, &new_symbols](
-      lldb::addr_t file_addr, uint32_t size, dw_offset_t) {
+  eh_frame->ForEachFDEEntries(
+      [this, symbol_table, section_list,
+       &new_symbols](lldb::addr_t file_addr, uint32_t size, dw_offset_t) {
         Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr);
         if (symbol) {
           if (!symbol->GetByteSizeIsValid()) {
             symbol->SetByteSize(size);
             symbol->SetSizeIsSynthesized(true);
           }
         } else {
           SectionSP section_sp =
               section_list->FindSectionContainingFileAddress(file_addr);
           if (section_sp) {
             addr_t offset = file_addr - section_sp->GetFileAddress();
             const char *symbol_name = GetNextSyntheticSymbolName().GetCString();
             uint64_t symbol_id = symbol_table->GetNumSymbols();
             Symbol eh_symbol(
                 symbol_id,       // Symbol table index.
                 symbol_name,     // Symbol name.
                 false,           // Is the symbol name mangled?
                 eSymbolTypeCode, // Type of this symbol.
                 true,            // Is this globally visible?
                 false,           // Is this symbol debug info?
                 false,           // Is this symbol a trampoline?
                 true,            // Is this symbol artificial?
-            section_sp,      // Section in which this symbol is defined or null.
-            offset,          // Offset in section or symbol value.
+                section_sp, // Section in which this symbol is defined or null.
+                offset,     // Offset in section or symbol value.
                 0,     // Size:          Don't specify the size as an FDE can
                 false, // Size is valid: cover multiple symbols.
                 false, // Contains linker annotations?
                 0);    // Symbol flags.
             new_symbols.push_back(eh_symbol);
           }
         }
         return true;
       });
 
   for (const Symbol &s : new_symbols)
     symbol_table->AddSymbol(s);
 }
 
 bool ObjectFileELF::IsStripped() {
   // TODO: determine this for ELF
   return false;

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::Error ParseThreadContextsFromNoteSegmentNetBSD(
+      const elf::ELFProgramHeader *segment_header,
+      lldb_private::DataExtractor segment_data);
+
+  // Parse thread(s) data structuresGeneric(prstatus, prpsinfo) from given NOTE
+  // segment
+  lldb_private::Error 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"
Error ProcessElfCore::DoLoadCore() {
   // Even if the architecture is set in the target, we need to override
   // it to match the core file which is always single arch.
   ArchSpec arch(m_core_module_sp->GetArchitecture());
 
   ArchSpec target_arch = GetTarget().GetArchitecture();
   ArchSpec core_arch(m_core_module_sp->GetArchitecture());
   target_arch.MergeFrom(core_arch);
   GetTarget().SetArchitecture(target_arch);
- 
   SetUnixSignals(UnixSignals::Create(GetArchitecture()));
 
   // Ensure we found at least one thread that was stopped on a signal.
   bool siginfo_signal_found = false;
   bool prstatus_signal_found = false;
   // Check we found a signal in a SIGINFO note.
   for (const auto &thread_data : m_thread_data) {
     if (thread_data.signo != 0)
size_t ProcessElfCore::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
   const lldb::addr_t file_start = address_range->data.GetRangeBase();
   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.
+  // 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);
 
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_PROCINFO_SIZE = 160, NT_AUXV = 2 };
+
+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 Error 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 Error(
+        "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 Error(
+        "Error parsing NetBSD core(5) notes: Unsupported procinfo size");
+
+  cpi_signo = data.GetU32(&offset); /* killing signal */
+
+  offset += 108;
+  cpi_nlwps = data.GetU32(&offset); /* number of LWPs */
+
+  offset += 32;
+  cpi_siglwp = data.GetU32(&offset); /* LWP target of killing signal */
+
+  return Error();
 }
 
 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.
+Error 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).
-Error ProcessElfCore::ParseThreadContextsFromNoteSegment(
+Error 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;
Error 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
+///
+Error 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) {
+        Error 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 Error("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 Error("Error parsing NetBSD core(5) notes: Unexpected order "
+                         "of NOTEs PT_GETFPREG before PT_GETREG");
+          m_thread_data.back().fpregset = note_data;
+        } else {
+          return Error(
+              "Error parsing NetBSD core(5) notes: Unsupported AMD64 NOTE");
+        }
+      } break;
+      default:
+        return Error(
+            "Error parsing NetBSD core(5) notes: Unsupported architecture");
+      }
+    } else {
+      return Error("Error parsing NetBSD core(5) notes: Unrecognized note");
+    }
+
+    offset += note_size;
+  }
+
+  if (m_thread_data.empty())
+    return Error("Error parsing NetBSD core(5) notes: No threads information "
+                 "specified in notes");
+
+  if (m_thread_data.size() != nlwps)
+    return Error("rror 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 Error(
+          "Error parsing NetBSD core(5) notes: Signal passed to unknown LWP");
+  }
+
+  return Error();
+}
+
 uint32_t ProcessElfCore::GetNumThreadContexts() {
   if (!m_thread_data_valid)
     DoLoadCore();
   return m_thread_data.size();
 }
 
 ArchSpec ProcessElfCore::GetArchitecture() {
   ObjectFileELF *core_file =
       (ObjectFileELF *)(m_core_module_sp->GetObjectFile());
   ArchSpec arch;
   core_file->GetArchitecture(arch);
 
   ArchSpec target_arch = GetTarget().GetArchitecture();
-  
   if (target_arch.IsMIPS())
     return target_arch;
 
   return arch;
 }
 
 const lldb::DataBufferSP ProcessElfCore::GetAuxvData() {
   const uint8_t *start = m_auxv.GetDataStart();