Battery of NetBSD support improvements

[krytarowski]

Summary

Include initial support for:

• single step mode (PT_STEP)
• single step trap handling (TRAP_TRACE)
• exec() trap (TRAP_EXEC)
• add placeholder interfaces for FPR
• initial code for NetBSD core(5) files
• minor tweaks

While there improve style of altered elf-core/ files.

This code raises the number of passing tests on NetBSD to around 50% (600+/1200+).

The introduced code is subject to improve afterwards for additional features and bug fixes.

Sponsored by <The NetBSD Foundation>

[krytarowski]

Next: watchpoints, FPR.

Current core(5) file format is a subject to change (AUXV can be shortened)... I'm working on the final nits for the NetBSD-8 interfaces.

[krytarowski]

Adding Jim as a reviewer, since Pavel is mostly out of the keyboard for longer time.

[labath]

source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

249

This is the third place i'm seeing this code. Any chance of turning it into a function?

432

I guess you should be playing with the pt_suspend/resume here to step only the requested thread(s). Is that something you plan to do as a follow up?

[krytarowski]

source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

249

Everything that touches threads will be refactored in future.

I suspect that at the end this code will lost its capability to iterate threads after exec() as all of them are terminated.

Here is a code that handles it in an expanded way and fore 1 thread only.

432

I'm planning to reuse PT_RESUME/PT_SUSPEND to select thread/s for execution.

And reuse PT_SETSTEP/PT_CLEARSTEP to mark them optionally for single-step mode.

And at the end use global PT_CONTINUE as it has option to emit a signal (PT_STEP cannot send a signal).

[krytarowski]

I think I will start the threading segment with proper handling of core(5) files. It looks like the simplest start point.

OpenBSD uses very similar format and can catch up quickly.

[kettenis]

The core file reading bits look ok to me.

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

382–383

Probably should update this comment

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

456

Unfortunate that the note numbers are different from architecture to architecture on NetBSD.

[krytarowski]

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

382–383

Right!

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

456

Yes, we reuse PT_GETREGS and PT_GETFPREGS per port variables.

This is placeholder to start working on amd64 with threading support.

[labath]

source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

249

That's fine, but if they're identical right now, you could still merge them together, right? (A lot of the temporary things have a tendency to become permanent).

432

Ok, as long as you're aware of that, I'm fine.

[krytarowski]

source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

249

I will merge this. Even if this is temporary solution.

[krytarowski]

Apply changes from review. No visible regressions in "check-lldb".

[jingham]

Kyril, I haven't been involved in the lldb-server parts of lldb. Greg sketched out those interfaces and mostly folks working on Windows & Linux have fleshed them out. I haven't been following the design discussions for lldb-server, and am not in a position to study them now. So I'm not a good person to review these changes.

You might try adding Greg as a reviewer, though I don't know how much time he will have right now, since he's starting a new job.

[krytarowski]

Thanks!

[labath]

Thank you. Keep up the good work.

[krytarowski]

Thanks! I noted that I introduced some bugs.. but I will fix them in future revisions. I will move on to threads now. FPR/watchpoints will be done later, on the cost on adding some code for cores and helping out with base system work.

LLDB/NetBSD is now out of the box functional as a debugger for a single thread.

source/Host/common/Host.cpp

Error Host::LaunchProcessPosixSpawn(const char *exe_path,
   lldb_utility::CleanUp<posix_spawnattr_t *, int> posix_spawnattr_cleanup(
       &attr, posix_spawnattr_destroy);
 
   sigset_t no_signals;
   sigset_t all_signals;
   sigemptyset(&no_signals);
   sigfillset(&all_signals);
   ::posix_spawnattr_setsigmask(&attr, &no_signals);
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
   ::posix_spawnattr_setsigdefault(&attr, &no_signals);
 #else
   ::posix_spawnattr_setsigdefault(&attr, &all_signals);
 #endif
 
   short flags = GetPosixspawnFlags(launch_info);
 
   error.SetError(::posix_spawnattr_setflags(&attr, flags), eErrorTypePOSIX);

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

if (pos == entry_list.end())
       m_removed_soentries.push_back(*I);
   }
 
   m_soentries = entry_list;
   return true;
 }
 
 bool DYLDRendezvous::SOEntryIsMainExecutable(const SOEntry &entry) {
-  // On Linux the executable is indicated by an empty path in the entry. On
-  // FreeBSD and on Android it is the full path to the executable.
+  // On some systes the executable is indicated by an empty path in the entry.
+  // On others it is the full path to the executable.
 
   auto triple = m_process->GetTarget().GetArchitecture().GetTriple();
   switch (triple.getOS()) {
   case llvm::Triple::FreeBSD:
+  case llvm::Triple::NetBSD:
     return entry.file_spec == m_exe_file_spec;
   case llvm::Triple::Linux:
     if (triple.isAndroid())
       return entry.file_spec == m_exe_file_spec;
     return !entry.file_spec;
   default:
     return false;
   }

source/Plugins/Process/NetBSD/NativeProcessNetBSD.h

private:
   void MonitorSignal(lldb::pid_t pid, int signal);
 
   Error GetSoftwareBreakpointPCOffset(uint32_t &actual_opcode_size);
   Error FixupBreakpointPCAsNeeded(NativeThreadNetBSD &thread);
   Error PopulateMemoryRegionCache();
   void SigchldHandler();
 
   ::pid_t Attach(lldb::pid_t pid, Error &error);
+
+  Error ReinitializeThreads();
 };
 
 } // namespace process_netbsd
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessNetBSD_H_

source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

case TRAP_BRKPT:
       for (const auto &thread_sp : m_threads) {
         static_pointer_cast<NativeThreadNetBSD>(thread_sp)
             ->SetStoppedByBreakpoint();
         FixupBreakpointPCAsNeeded(
             *static_pointer_cast<NativeThreadNetBSD>(thread_sp));
       }
       SetState(StateType::eStateStopped, true);
       break;
+    case TRAP_TRACE:
+      for (const auto &thread_sp : m_threads) {
+        static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetStoppedByTrace();
+      }
+      SetState(StateType::eStateStopped, true);
+      break;
+    case TRAP_EXEC: {
+      Error error = ReinitializeThreads();
+      if (error.Fail()) {
+        SetState(StateType::eStateInvalid);
+        return;
+      }
+
+      // Let our delegate know we have just exec'd.
+      NotifyDidExec();
+
+      SetState(StateType::eStateStopped, true);
+    } break;
     }
   }
 }
 
 void NativeProcessNetBSD::MonitorSignal(lldb::pid_t pid, int signal) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
   ptrace_siginfo_t info;
const ResumeAction *const action =
       resume_actions.GetActionForThread(thread_sp->GetID(), true);
 
   if (action == nullptr) {
     LLDB_LOG(log, "no action specified for pid {0} tid {1}", GetID(),
              thread_sp->GetID());
     return Error();
   }
 
+  Error error;
+
   switch (action->state) {
   case eStateRunning: {
     // Run the thread, possibly feeding it the signal.
-    Error error = NativeProcessNetBSD::PtraceWrapper(PT_CONTINUE, GetID(),
-                                                     (void *)1, action->signal);
+    error = NativeProcessNetBSD::PtraceWrapper(PT_CONTINUE, GetID(), (void *)1,
+                                               action->signal);
     if (!error.Success())
       return error;
     for (const auto &thread_sp : m_threads) {
       static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetRunning();
     }
     SetState(eStateRunning, true);
     break;
   }
   case eStateStepping:
-    return Error("Not implemented");
+    // Run the thread, possibly feeding it the signal.
+    error = NativeProcessNetBSD::PtraceWrapper(PT_STEP, GetID(), (void *)1,
+                                               action->signal);
+    if (!error.Success())
+      return error;
+    for (const auto &thread_sp : m_threads) {
+      static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetStepping();
+    }
+    SetState(eStateStepping, true);
     break;
 
   case eStateSuspended:
   case eStateStopped:
     llvm_unreachable("Unexpected state");
 
   default:
     return Error("NativeProcessLinux::%s (): unexpected state %s specified "
if (error.Fail()) {
       return error;
     }
   }
 
   LLDB_LOG(log, "adding pid = {0}", pid);
 
   ResolveProcessArchitecture(m_pid, m_arch);
 
-  /* Initialize threads */
-  struct ptrace_lwpinfo info = {};
-  error = PtraceWrapper(PT_LWPINFO, pid, &info, sizeof(info));
-  if (error.Fail()) {
-    SetState(StateType::eStateInvalid);
-    return error;
-  }
-  while (info.pl_lwpid != 0) {
-    NativeThreadNetBSDSP thread_sp = AddThread(info.pl_lwpid);
-    thread_sp->SetStoppedBySignal(SIGSTOP);
-    error = PtraceWrapper(PT_LWPINFO, pid, &info, sizeof(info));
-    if (error.Fail()) {
-      SetState(StateType::eStateInvalid);
-      return error;
-    }
-  }
+  error = ReinitializeThreads();
 
   /* Set process stopped */
   SetState(StateType::eStateStopped);
 
   if (error.Fail())
     LLDB_LOG(log, "inferior launching failed {0}", error);
   return error;
 }
NativeThreadNetBSDSP NativeProcessNetBSD::AddThread(lldb::tid_t thread_id) {
   auto thread_sp = std::make_shared<NativeThreadNetBSD>(this, thread_id);
   m_threads.push_back(thread_sp);
   return thread_sp;
 }
 
 ::pid_t NativeProcessNetBSD::Attach(lldb::pid_t pid, Error &error) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-  // Use a map to keep track of the threads which we have attached/need to
-  // attach.
-  Host::TidMap tids_to_attach;
   if (pid <= 1) {
     error.SetErrorToGenericError();
     error.SetErrorString("Attaching to process 1 is not allowed.");
     return -1;
   }
 
   // Attach to the requested process.
   // An attach will cause the thread to stop with a SIGSTOP.
   error = PtraceWrapper(PT_ATTACH, pid);
   if (error.Fail())
     return -1;
 
   int status;
   // Need to use WALLSIG otherwise we receive an error with errno=ECHLD
   // At this point we should have a thread stopped if waitpid succeeds.
   if ((status = waitpid(pid, NULL, WALLSIG)) < 0)
     return -1;
 
   m_pid = pid;
 
   /* Initialize threads */
-  struct ptrace_lwpinfo info = {};
-  error = PtraceWrapper(PT_LWPINFO, pid, &info, sizeof(info));
+  error = ReinitializeThreads();
   if (error.Fail()) {
     SetState(StateType::eStateInvalid);
     return -1;
   }
-  while (info.pl_lwpid != 0) {
-    NativeThreadNetBSDSP thread_sp = AddThread(info.pl_lwpid);
-    thread_sp->SetStoppedBySignal(SIGSTOP);
-    error = PtraceWrapper(PT_LWPINFO, pid, &info, sizeof(info));
-    if (error.Fail()) {
-      SetState(StateType::eStateInvalid);
-      return -1;
-    }
-  }
 
   // Let our process instance know the thread has stopped.
   SetState(StateType::eStateStopped);
 
   return pid;
 }
 
 Error NativeProcessNetBSD::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
NativeProcessNetBSD::GetAuxvData() const {
   if (error.Fail())
     return std::error_code(error.GetError(), std::generic_category());
 
   if (io.piod_len < 1)
     return std::error_code(ECANCELED, std::generic_category());
 
   return buf;
 }
+
+Error NativeProcessNetBSD::ReinitializeThreads() {
+  // Clear old threads
+  m_threads.clear();
+
+  // Initialize new thread
+  struct ptrace_lwpinfo info = {};
+  Error error = PtraceWrapper(PT_LWPINFO, GetID(), &info, sizeof(info));
+  if (error.Fail()) {
+    return error;
+  }
+  // Reinitialize from scratch threads and register them in process
+  while (info.pl_lwpid != 0) {
+    NativeThreadNetBSDSP thread_sp = AddThread(info.pl_lwpid);
+    thread_sp->SetStoppedByExec();
+    error = PtraceWrapper(PT_LWPINFO, GetID(), &info, sizeof(info));
+    if (error.Fail()) {
+      return error;
+    }
+  }
+
+  return error;
+}

source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD.h

public:
   static NativeRegisterContextNetBSD *
   CreateHostNativeRegisterContextNetBSD(const ArchSpec &target_arch,
                                         NativeThreadProtocol &native_thread,
                                         uint32_t concrete_frame_idx);
 
 protected:
   virtual Error ReadGPR();
   virtual Error WriteGPR();
+
+  virtual Error ReadFPR();
+  virtual Error WriteFPR();
+
   virtual void *GetGPRBuffer() { return nullptr; }
   virtual size_t GetGPRSize() {
     return GetRegisterInfoInterface().GetGPRSize();
   }
+
+  virtual void *GetFPRBuffer() { return nullptr; }
+  virtual size_t GetFPRSize() { return 0; }
+
   virtual Error DoReadGPR(void *buf);
   virtual Error DoWriteGPR(void *buf);
 
+  virtual Error DoReadFPR(void *buf);
+  virtual Error DoWriteFPR(void *buf);
+
   virtual NativeProcessNetBSD &GetProcess();
   virtual ::pid_t GetProcessPid();
 };
 
 } // namespace process_netbsd
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextNetBSD_h

source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD.cpp

 Error NativeRegisterContextNetBSD::WriteGPR() {
   void *buf = GetGPRBuffer();
   if (!buf)
     return Error("GPR buffer is NULL");
 
   return DoWriteGPR(buf);
 }
 
+Error NativeRegisterContextNetBSD::ReadFPR() {
+  void *buf = GetFPRBuffer();
+  if (!buf)
+    return Error("FPR buffer is NULL");
+
+  return DoReadFPR(buf);
+}
+
+Error NativeRegisterContextNetBSD::WriteFPR() {
+  void *buf = GetFPRBuffer();
+  if (!buf)
+    return Error("FPR buffer is NULL");
+
+  return DoWriteFPR(buf);
+}
+
 Error NativeRegisterContextNetBSD::DoReadGPR(void *buf) {
   return NativeProcessNetBSD::PtraceWrapper(PT_GETREGS, GetProcessPid(), buf,
                                             m_thread.GetID());
 }
 
 Error NativeRegisterContextNetBSD::DoWriteGPR(void *buf) {
   return NativeProcessNetBSD::PtraceWrapper(PT_SETREGS, GetProcessPid(), buf,
                                             m_thread.GetID());
 }
 
+Error NativeRegisterContextNetBSD::DoReadFPR(void *buf) {
+  return NativeProcessNetBSD::PtraceWrapper(PT_GETFPREGS, GetProcessPid(), buf,
+                                            m_thread.GetID());
+}
+
+Error NativeRegisterContextNetBSD::DoWriteFPR(void *buf) {
+  return NativeProcessNetBSD::PtraceWrapper(PT_SETFPREGS, GetProcessPid(), buf,
+                                            m_thread.GetID());
+}
+
 NativeProcessNetBSD &NativeRegisterContextNetBSD::GetProcess() {
   auto process_sp =
       std::static_pointer_cast<NativeProcessNetBSD>(m_thread.GetProcess());
   assert(process_sp);
   return *process_sp;
 }
 
 ::pid_t NativeRegisterContextNetBSD::GetProcessPid() {
   NativeProcessNetBSD &process = GetProcess();
   lldb::pid_t pid = process.GetID();
 
   return pid;
 }

source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.h

Error WriteRegister(const RegisterInfo *reg_info,
                       const RegisterValue &reg_value) override;
 
   Error ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   Error WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
 protected:
   void *GetGPRBuffer() override { return &m_gpr_x86_64; }
+  void *GetFPRBuffer() override { return &m_fpr_x86_64; }
 
 private:
   // Private member types.
-  enum { GPRegSet };
+  enum { GPRegSet, FPRegSet };
 
   // Private member variables.
   struct reg m_gpr_x86_64;
+  struct fpreg m_fpr_x86_64;
 
   int GetSetForNativeRegNum(int reg_num) const;
 
   int ReadRegisterSet(uint32_t set);
   int WriteRegisterSet(uint32_t set);
 };
 
 } // namespace process_netbsd
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextNetBSD_x86_64_h
 
 #endif // defined(__x86_64__)

source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.cpp

else
     return -1;
 }
 
 int NativeRegisterContextNetBSD_x86_64::ReadRegisterSet(uint32_t set) {
   switch (set) {
   case GPRegSet:
     ReadGPR();
     return 0;
+  case FPRegSet:
+    ReadFPR();
+    return 0;
   default:
     break;
   }
   return -1;
 }
 int NativeRegisterContextNetBSD_x86_64::WriteRegisterSet(uint32_t set) {
   switch (set) {
   case GPRegSet:
     WriteGPR();
     return 0;
+  case FPRegSet:
+    WriteFPR();
+    return 0;
   default:
     break;
   }
   return -1;
 }
 
 Error NativeRegisterContextNetBSD_x86_64::ReadRegister(
     const RegisterInfo *reg_info, RegisterValue &reg_value) {

source/Plugins/Process/NetBSD/NativeThreadNetBSD.h

 
 private:
   // ---------------------------------------------------------------------
   // Interface for friend classes
   // ---------------------------------------------------------------------
 
   void SetStoppedBySignal(uint32_t signo, const siginfo_t *info = nullptr);
   void SetStoppedByBreakpoint();
+  void SetStoppedByTrace();
+  void SetStoppedByExec();
   void SetStopped();
   void SetRunning();
+  void SetStepping();
 
   // ---------------------------------------------------------------------
   // Member Variables
   // ---------------------------------------------------------------------
   lldb::StateType m_state;
   ThreadStopInfo m_stop_info;
   NativeRegisterContextSP m_reg_context_sp;
   std::string m_stop_description;
 };
 
 typedef std::shared_ptr<NativeThreadNetBSD> NativeThreadNetBSDSP;
 } // namespace process_netbsd
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeThreadNetBSD_H_

source/Plugins/Process/NetBSD/NativeThreadNetBSD.cpp

 }
 
 void NativeThreadNetBSD::SetStoppedByBreakpoint() {
   SetStopped();
   m_stop_info.reason = StopReason::eStopReasonBreakpoint;
   m_stop_info.details.signal.signo = SIGTRAP;
 }
 
+void NativeThreadNetBSD::SetStoppedByTrace() {
+  SetStopped();
+  m_stop_info.reason = StopReason::eStopReasonTrace;
+  m_stop_info.details.signal.signo = SIGTRAP;
+}
+
+void NativeThreadNetBSD::SetStoppedByExec() {
+  SetStopped();
+  m_stop_info.reason = StopReason::eStopReasonExec;
+  m_stop_info.details.signal.signo = SIGTRAP;
+}
+
 void NativeThreadNetBSD::SetStopped() {
   const StateType new_state = StateType::eStateStopped;
   m_state = new_state;
   m_stop_description.clear();
 }
 
 void NativeThreadNetBSD::SetRunning() {
   m_state = StateType::eStateRunning;
   m_stop_info.reason = StopReason::eStopReasonNone;
 }
 
+void NativeThreadNetBSD::SetStepping() {
+  m_state = StateType::eStateStepping;
+  m_stop_info.reason = StopReason::eStopReasonNone;
+}
+
 std::string NativeThreadNetBSD::GetName() { return std::string(""); }
 
 lldb::StateType NativeThreadNetBSD::GetState() { return m_state; }
 
 bool NativeThreadNetBSD::GetStopReason(ThreadStopInfo &stop_info,
                                        std::string &description) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
 

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

lldb::ProcessSP ProcessElfCore::CreateInstance(lldb::TargetSP target_sp,
                                                const FileSpec *crash_file) {
   lldb::ProcessSP process_sp;
   if (crash_file) {
     // Read enough data for a ELF32 header or ELF64 header
     // Note: Here we care about e_type field only, so it is safe
     // to ignore possible presence of the header extension.
     const size_t header_size = sizeof(llvm::ELF::Elf64_Ehdr);
 
-    auto data_sp =
-        DataBufferLLVM::CreateSliceFromPath(crash_file->GetPath(), header_size, 0);
+    auto data_sp = DataBufferLLVM::CreateSliceFromPath(crash_file->GetPath(),
+                                                       header_size, 0);
     if (data_sp && data_sp->GetByteSize() == header_size &&
         elf::ELFHeader::MagicBytesMatch(data_sp->GetBytes())) {
       elf::ELFHeader elf_header;
       DataExtractor data(data_sp, lldb::eByteOrderLittle, 4);
       lldb::offset_t data_offset = 0;
       if (elf_header.Parse(data, &data_offset)) {
         if (elf_header.e_type == llvm::ELF::ET_CORE)
           process_sp.reset(
if (arch.IsValid())
     GetTarget().SetArchitecture(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) {
+  for (const auto &thread_data : m_thread_data) {
     if (thread_data.signo != 0)
       siginfo_signal_found = true;
     if (thread_data.prstatus_sig != 0)
       prstatus_signal_found = true;
   }
   if (!siginfo_signal_found) {
     // If we don't have signal from SIGINFO use the signal from each threads
     // PRSTATUS note.
     if (prstatus_signal_found) {
-      for (auto &thread_data: m_thread_data)
+      for (auto &thread_data : m_thread_data)
         thread_data.signo = thread_data.prstatus_sig;
     } else if (m_thread_data.size() > 0) {
       // If all else fails force the first thread to be SIGSTOP
       m_thread_data.begin()->signo =
           GetUnixSignals()->GetSignalNumberFromName("SIGSTOP");
     }
   }
 
enum {
   NT_FPREGSET,
   NT_PRPSINFO,
   NT_THRMISC = 7,
   NT_PROCSTAT_AUXV = 16,
   NT_PPC_VMX = 0x100
 };
 }
 
+namespace NETBSD {
+
+enum { NT_PROCINFO = 1, NT_AUXV, NT_AMD64_REGS = 33, NT_AMD64_FPREGS = 35 };
+}
+
 // 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 ParseOpenBSDProcInfo(ThreadData &thread_data, DataExtractor &data)
-{
+static void ParseNetBSDProcInfo(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);
+}
+
+static void ParseOpenBSDProcInfo(ThreadData &thread_data, DataExtractor &data) {
   lldb::offset_t offset = 0;
-  
   int version = data.GetU32(&offset);
   if (version != 1)
-    return;
+    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.
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;
+        ParseOpenBSDProcInfo(*thread_data, note_data);
+        break;
       case NT_OPENBSD_AUXV:
-  m_auxv = DataExtractor(note_data);
-  break;
+        m_auxv = DataExtractor(note_data);
+        break;
       case NT_OPENBSD_REGS:
-  thread_data->gpregset = note_data;
-  break;
+        thread_data->gpregset = note_data;
+        break;
       case NT_OPENBSD_FPREGS:
-  thread_data->fpregset = note_data;
-  break;
+        thread_data->fpregset = note_data;
+        break;
       }
     } else if (note.n_name == "CORE") {
       switch (note.n_type) {
       case NT_PRSTATUS:
         have_prstatus = true;
         error = prstatus.Parse(note_data, arch);
         if (error.Fail())
           return error;

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

 
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_s390x.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
+#include "Plugins/Process/Utility/RegisterContextNetBSD_x86_64.h"
 #include "Plugins/Process/Utility/RegisterContextOpenBSD_i386.h"
 #include "Plugins/Process/Utility/RegisterContextOpenBSD_x86_64.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
 #include "ProcessElfCore.h"
 #include "RegisterContextPOSIXCore_arm.h"
 #include "RegisterContextPOSIXCore_arm64.h"
 #include "RegisterContextPOSIXCore_mips64.h"
case llvm::Triple::FreeBSD: {
         reg_interface = new RegisterContextFreeBSD_x86_64(arch);
         break;
       default:
         break;
       }
       break;
     }
 
+    case llvm::Triple::NetBSD: {
+      switch (arch.GetMachine()) {
+      case llvm::Triple::x86_64:
+        reg_interface = new RegisterContextNetBSD_x86_64(arch);
+        break;
+      default:
+        break;
+      }
+      break;
+    }
+
     case llvm::Triple::Linux: {
       switch (arch.GetMachine()) {
       case llvm::Triple::arm:
         reg_interface = new RegisterInfoPOSIX_arm(arch);
         break;
       case llvm::Triple::aarch64:
         reg_interface = new RegisterInfoPOSIX_arm64(arch);
         break;
case llvm::Triple::OpenBSD: {
       switch (arch.GetMachine()) {
       case llvm::Triple::aarch64:
         reg_interface = new RegisterInfoPOSIX_arm64(arch);
         break;
       case llvm::Triple::arm:
         reg_interface = new RegisterInfoPOSIX_arm(arch);
         break;
       case llvm::Triple::x86:
-  reg_interface = new RegisterContextOpenBSD_i386(arch);
-  break;
+        reg_interface = new RegisterContextOpenBSD_i386(arch);
+        break;
       case llvm::Triple::x86_64:
         reg_interface = new RegisterContextOpenBSD_x86_64(arch);
         break;
       default:
         break;
       }
       break;
     }
Error ELFLinuxPrStatus::Parse(DataExtractor &data, ArchSpec &arch) {
   pr_stime.tv_usec = data.GetPointer(&offset);
 
   pr_cutime.tv_sec = data.GetPointer(&offset);
   pr_cutime.tv_usec = data.GetPointer(&offset);
 
   pr_cstime.tv_sec = data.GetPointer(&offset);
   pr_cstime.tv_usec = data.GetPointer(&offset);
 
-
   return error;
 }
 
 //----------------------------------------------------------------
 // Parse PRPSINFO from NOTE entry
 //----------------------------------------------------------------
 ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() {
   memset(this, 0, sizeof(ELFLinuxPrPsInfo));
Error ELFLinuxPrPsInfo::Parse(DataExtractor &data, ArchSpec &arch) {
   offset += size;
 
   return error;
 }
 
 //----------------------------------------------------------------
 // Parse SIGINFO from NOTE entry
 //----------------------------------------------------------------
-ELFLinuxSigInfo::ELFLinuxSigInfo() {
-  memset(this, 0, sizeof(ELFLinuxSigInfo));
-}
+ELFLinuxSigInfo::ELFLinuxSigInfo() { memset(this, 0, sizeof(ELFLinuxSigInfo)); }
 
 Error ELFLinuxSigInfo::Parse(DataExtractor &data, const ArchSpec &arch) {
   Error 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;