Start migrating away from threaddata containing the signal data

Jlalond · Jlalond · commit babd0e14fe9f · 2024-10-09T13:16:47.000-07:00
diff --git a/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp b/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp
@@ -232,7 +232,7 @@ Status ProcessElfCore::DoLoadCore() {
   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)
+    if (thread_data.siginfo.si_signo != 0)
       siginfo_signal_found = true;
     if (thread_data.prstatus_sig != 0)
       prstatus_signal_found = true;
@@ -242,10 +242,10 @@ Status ProcessElfCore::DoLoadCore() {
     // PRSTATUS note.
     if (prstatus_signal_found) {
       for (auto &thread_data : m_thread_data)
-        thread_data.signo = thread_data.prstatus_sig;
+        thread_data.siginfo.si_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 =
+      m_thread_data.begin()->siginfo.si_signo =
           GetUnixSignals()->GetSignalNumberFromName("SIGSTOP");
     }
   }
@@ -493,7 +493,7 @@ static void ParseFreeBSDPrStatus(ThreadData &thread_data,
   else
     offset += 16;
 
-  thread_data.signo = data.GetU32(&offset); // pr_cursig
+  thread_data.siginfo.si_signo = data.GetU32(&offset); // pr_cursig
   thread_data.tid = data.GetU32(&offset);   // pr_pid
   if (lp64)
     offset += 4;
@@ -576,7 +576,7 @@ static void ParseOpenBSDProcInfo(ThreadData &thread_data,
     return;
 
   offset += 4;
-  thread_data.signo = data.GetU32(&offset);
+  thread_data.siginfo.si_signo = data.GetU32(&offset);
 }
 
 llvm::Expected<std::vector<CoreNote>>
@@ -814,15 +814,15 @@ llvm::Error ProcessElfCore::parseNetBSDNotes(llvm::ArrayRef<CoreNote> notes) {
   // Signal targeted at the whole process.
   if (siglwp == 0) {
     for (auto &data : m_thread_data)
-      data.signo = signo;
+      data.siginfo.si_signo = signo;
   }
   // Signal destined for a particular LWP.
   else {
     bool passed = false;
 
     for (auto &data : m_thread_data) {
       if (data.tid == siglwp) {
-        data.signo = signo;
+        data.siginfo.si_signo = signo;
         passed = true;
         break;
       }
@@ -930,9 +930,7 @@ llvm::Error ProcessElfCore::parseLinuxNotes(llvm::ArrayRef<CoreNote> notes) {
       Status status = siginfo.Parse(note.data, arch, unix_signals);
       if (status.Fail())
         return status.ToError();
-      thread_data.signo = siginfo.si_signo;
-      thread_data.code = siginfo.si_code;
-      thread_data.description = siginfo.GetDescription(unix_signals);
+      thread_data.siginfo = siginfo;
       break;
     }
     case ELF::NT_FILE: {
diff --git a/lldb/source/Plugins/Process/elf-core/ThreadElfCore.cpp b/lldb/source/Plugins/Process/elf-core/ThreadElfCore.cpp
@@ -49,16 +49,17 @@ using namespace lldb_private;
 
 // Construct a Thread object with given data
 ThreadElfCore::ThreadElfCore(Process &process, const ThreadData &td)
-    : Thread(process, td.tid), m_thread_name(td.name), m_thread_reg_ctx_sp(),
-      m_signo(td.signo), m_code(td.code), m_sig_description(td.description),
-      m_gpregset_data(td.gpregset), m_notes(td.notes) {}
+    : Thread(process, td.tid), m_thread_reg_ctx_sp(),
+      m_gpregset_data(td.gpregset), m_notes(td.notes), m_siginfo(std::move(td.siginfo)) {}
 
 ThreadElfCore::~ThreadElfCore() { DestroyThread(); }
 
 void ThreadElfCore::RefreshStateAfterStop() {
   GetRegisterContext()->InvalidateIfNeeded(false);
 }
 
+
+
 RegisterContextSP ThreadElfCore::GetRegisterContext() {
   if (!m_reg_context_sp) {
     m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
@@ -241,8 +242,15 @@ bool ThreadElfCore::CalculateStopInfo() {
   if (!process_sp)
     return false;
 
+  lldb::UnixSignalsSP unix_signals_sp(process_sp->GetUnixSignals());
+  if (!unix_signals_sp)
+    return false;
+
   SetStopInfo(StopInfo::CreateStopReasonWithSignal(
-      *this, m_signo, m_sig_description.c_str(), m_code));
+      *this, m_siginfo.si_signo, 
+      m_siginfo.GetDescription(*unix_signals_sp).c_str(), m_siginfo.si_code));
+
+  SetStopInfo(m_stop_info_sp);
   return true;
 }
 
@@ -567,34 +575,34 @@ Status ELFLinuxSigInfo::Parse(const DataExtractor &data, const ArchSpec &arch,
   if (unix_signals.GetShouldStop(si_signo)) {
     // Instead of memcpy we call all these individually as the extractor will
     // handle endianness for us.
-    _sigfault.sig_addr = data.GetAddress(&offset);
-    _sigfault.sig_addr_lsb = data.GetU16(&offset);
-    if (data.GetByteSize() - offset >= sizeof(_sigfault._bounds)) {
-      _sigfault._bounds._addr_bnd._lower = data.GetAddress(&offset);
-      _sigfault._bounds._addr_bnd._upper = data.GetAddress(&offset);
-      _sigfault._bounds._pkey = data.GetU32(&offset);
+    sigfault.si_addr = data.GetAddress(&offset);
+    sigfault.si_addr_lsb = data.GetU16(&offset);
+    if (data.GetByteSize() - offset >= sizeof(sigfault.bounds)) {
+      sigfault.bounds._addr_bnd._lower = data.GetAddress(&offset);
+      sigfault.bounds._addr_bnd._upper = data.GetAddress(&offset);
+      sigfault.bounds._pkey = data.GetU32(&offset);
     } else {
       // Set these to 0 so we don't use bogus data for the description.
-      _sigfault._bounds._addr_bnd._lower = 0;
-      _sigfault._bounds._addr_bnd._upper = 0;
-      _sigfault._bounds._pkey = 0;
+      sigfault.bounds._addr_bnd._lower = 0;
+      sigfault.bounds._addr_bnd._upper = 0;
+      sigfault.bounds._pkey = 0;
     }
   }
 
   return error;
 }
 
 std::string
-ELFLinuxSigInfo::GetDescription(const lldb_private::UnixSignals &unix_signals) {
-  if (unix_signals.GetShouldStop(si_signo)) {
-    if (_sigfault._bounds._addr_bnd._upper != 0)
+ELFLinuxSigInfo::GetDescription(const lldb_private::UnixSignals &unix_signals) const {
+  if (unix_signals.GetShouldStop(si_signo) && sigfault.si_addr != 0) {
+    if (sigfault.bounds._addr_bnd._upper != 0)
       return unix_signals.GetSignalDescription(
-          si_signo, si_code, _sigfault.sig_addr,
-          _sigfault._bounds._addr_bnd._lower,
-          _sigfault._bounds._addr_bnd._upper);
+          si_signo, si_code, sigfault.si_addr,
+          sigfault.bounds._addr_bnd._lower,
+          sigfault.bounds._addr_bnd._upper);
     else
       return unix_signals.GetSignalDescription(si_signo, si_code,
-                                                   _sigfault.sig_addr);
+                                                   sigfault.si_addr);
   }
 
   return unix_signals.GetSignalDescription(si_signo, si_code);
diff --git a/lldb/source/Plugins/Process/elf-core/ThreadElfCore.h b/lldb/source/Plugins/Process/elf-core/ThreadElfCore.h
@@ -35,6 +35,8 @@ class ProcessInstanceInfo;
 #undef si_signo
 #undef si_code
 #undef si_errno
+#undef si_addr
+#undef si_addr_lsb
 
 struct ELFLinuxPrStatus {
   int32_t si_signo;
@@ -76,15 +78,15 @@ static_assert(sizeof(ELFLinuxPrStatus) == 112,
               "sizeof ELFLinuxPrStatus is not correct!");
 
 struct ELFLinuxSigInfo {
+
   int32_t si_signo; // Order matters for the first 3.
   int32_t si_errno;
   int32_t si_code;
   // Copied from siginfo_t so we don't have to include signal.h on non 'Nix
-  // builds, we add `g` to the si_ prefix because siginfo_t defines them as
-  // macros.
+  // builds.
   struct {
-    lldb::addr_t sig_addr;  /* faulting insn/memory ref. */
-    short int sig_addr_lsb; /* Valid LSB of the reported address.  */
+    lldb::addr_t si_addr;  /* faulting insn/memory ref. */
+    short int si_addr_lsb; /* Valid LSB of the reported address.  */
     union {
       /* used when si_code=SEGV_BNDERR */
       struct {
@@ -93,16 +95,16 @@ struct ELFLinuxSigInfo {
       } _addr_bnd;
       /* used when si_code=SEGV_PKUERR */
       uint32_t _pkey;
-    } _bounds;
-  } _sigfault;
+    } bounds;
+  } sigfault;
 
   ELFLinuxSigInfo();
 
   lldb_private::Status Parse(const lldb_private::DataExtractor &data,
                              const lldb_private::ArchSpec &arch,
                              const lldb_private::UnixSignals &unix_signals);
 
-  std::string GetDescription(const lldb_private::UnixSignals &unix_signals);
+  std::string GetDescription(const lldb_private::UnixSignals &unix_signals) const;
 
   // Return the bytesize of the structure
   // 64 bit - just sizeof
@@ -161,11 +163,9 @@ struct ThreadData {
   lldb_private::DataExtractor gpregset;
   std::vector<lldb_private::CoreNote> notes;
   lldb::tid_t tid;
-  int signo = 0;
-  int code = 0;
-  int prstatus_sig = 0;
-  std::string description;
   std::string name;
+  ELFLinuxSigInfo siginfo;
+  int prstatus_sig = 0;
 };
 
 class ThreadElfCore : public lldb_private::Thread {
@@ -196,17 +196,16 @@ class ThreadElfCore : public lldb_private::Thread {
       m_thread_name.clear();
   }
 
+  void CreateStopFromSigInfo(const ELFLinuxSigInfo &siginfo, const lldb_private::UnixSignals &unix_signals);
+
 protected:
   // Member variables.
   std::string m_thread_name;
   lldb::RegisterContextSP m_thread_reg_ctx_sp;
 
-  int m_signo;
-  int m_code;
-  std::string m_sig_description;
-
   lldb_private::DataExtractor m_gpregset_data;
   std::vector<lldb_private::CoreNote> m_notes;
+  ELFLinuxSigInfo m_siginfo;
 
   bool CalculateStopInfo() override;
 };
