[lldb] Add a NativeProcessProtocol::Threads() iterable

[mgorny]

Summary

Sponsored by: The FreeBSD Foundation

lldb/include/lldb/Host/common/NativeProcessProtocol.h

 #define LLDB_HOST_COMMON_NATIVEPROCESSPROTOCOL_H
 
 #include "NativeBreakpointList.h"
 #include "NativeThreadProtocol.h"
 #include "NativeWatchpointList.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/Iterable.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/TraceGDBRemotePackets.h"
 #include "lldb/Utility/UnimplementedError.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
struct SVR4LibraryInfo {
   lldb::addr_t next;
 };
 
 // NativeProcessProtocol
 class NativeProcessProtocol {
 public:
   virtual ~NativeProcessProtocol() = default;
 
+  typedef std::vector<std::unique_ptr<NativeThreadProtocol>> thread_collection;
+  template <typename I>
+  static NativeThreadProtocol &thread_list_adapter(I &iter) {
+    assert(*iter);
+    return **iter;
+  }
+  typedef LockingAdaptedIterable<thread_collection, NativeThreadProtocol &,
+                                 thread_list_adapter, std::recursive_mutex>
+      ThreadIterable;
+
   virtual Status Resume(const ResumeActionList &resume_actions) = 0;
 
   virtual Status Halt() = 0;
 
   virtual Status Detach() = 0;
 
   /// Sends a process a UNIX signal \a signal.
   ///
public:
   void SetCurrentThreadID(lldb::tid_t tid) { m_current_thread_id = tid; }
 
   lldb::tid_t GetCurrentThreadID() const { return m_current_thread_id; }
 
   NativeThreadProtocol *GetCurrentThread() {
     return GetThreadByID(m_current_thread_id);
   }
 
+  ThreadIterable Threads() const {
+    return ThreadIterable(m_threads, m_threads_mutex);
+  }
+
   // Access to inferior stdio
   virtual int GetTerminalFileDescriptor() { return m_terminal_fd; }
 
   // Stop id interface
 
   uint32_t GetStopID() const;
 
   // Callbacks for low-level process state changes

lldb/source/Plugins/Process/Linux/IntelPTCollector.cpp

if (request.IsPerCpuTracing()) {
                                                      m_process)) {
         m_process_trace_up = std::move(*trace);
         return Error::success();
       } else {
         return trace.takeError();
       }
     } else {
       std::vector<lldb::tid_t> process_threads;
-      for (size_t i = 0; m_process.GetThreadAtIndex(i); i++)
-        process_threads.push_back(m_process.GetThreadAtIndex(i)->GetID());
+      for (NativeThreadProtocol &thread : m_process.Threads())
+        process_threads.push_back(thread.GetID());
 
       // per-thread process tracing
       if (Expected<IntelPTProcessTraceUP> trace =
               IntelPTPerThreadProcessTrace::Start(request, process_threads)) {
         m_process_trace_up = std::move(trace.get());
         return Error::success();
       } else {
         return trace.takeError();

lldb/source/Plugins/Process/Linux/IntelPTMultiCoreTrace.cpp

if (Error err = core_trace.Resume()) {
                      "Unable to resume the core trace for core {0}", cpu_id);
     }
   });
 }
 
 TraceIntelPTGetStateResponse IntelPTMultiCoreTrace::GetState() {
   TraceIntelPTGetStateResponse state;
 
-  for (size_t i = 0; m_process.GetThreadAtIndex(i); i++)
+  for (NativeThreadProtocol &thread : m_process.Threads())
     state.traced_threads.push_back(
-        TraceThreadState{m_process.GetThreadAtIndex(i)->GetID(), {}});
+        TraceThreadState{thread.GetID(), {}});
 
   state.cpus.emplace();
   ForEachCore([&](lldb::cpu_id_t cpu_id,
                   const IntelPTSingleBufferTrace &core_trace,
                   const ContextSwitchTrace &context_switch_trace) {
     state.cpus->push_back(
         {cpu_id,
          {{IntelPTDataKinds::kIptTrace, core_trace.GetIptTraceSize()},

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 
 static llvm::Expected<json::Array>
 GetJSONThreadsInfo(NativeProcessProtocol &process, bool abridged) {
   Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread);
 
   json::Array threads_array;
 
   // Ensure we can get info on the given thread.
-  uint32_t thread_idx = 0;
-  for (NativeThreadProtocol *thread;
-       (thread = process.GetThreadAtIndex(thread_idx)) != nullptr;
-       ++thread_idx) {
-
-    lldb::tid_t tid = thread->GetID();
-
+  for (NativeThreadProtocol &thread : process.Threads()) {
+    lldb::tid_t tid = thread.GetID();
     // Grab the reason this thread stopped.
     struct ThreadStopInfo tid_stop_info;
     std::string description;
-    if (!thread->GetStopReason(tid_stop_info, description))
+    if (!thread.GetStopReason(tid_stop_info, description))
       return llvm::make_error<llvm::StringError>(
           "failed to get stop reason", llvm::inconvertibleErrorCode());
 
     const int signum = tid_stop_info.signo;
     if (log) {
       LLDB_LOGF(log,
                 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
                 " tid %" PRIu64
                 " got signal signo = %d, reason = %d, exc_type = %" PRIu64,
                 __FUNCTION__, process.GetID(), tid, signum,
                 tid_stop_info.reason, tid_stop_info.details.exception.type);
     }
 
     json::Object thread_obj;
 
     if (!abridged) {
-      if (llvm::Optional<json::Object> registers = GetRegistersAsJSON(*thread))
+      if (llvm::Optional<json::Object> registers = GetRegistersAsJSON(thread))
         thread_obj.try_emplace("registers", std::move(*registers));
     }
 
     thread_obj.try_emplace("tid", static_cast<int64_t>(tid));
 
     if (signum != 0)
       thread_obj.try_emplace("signal", signum);
 
-    const std::string thread_name = thread->GetName();
+    const std::string thread_name = thread.GetName();
     if (!thread_name.empty())
       thread_obj.try_emplace("name", thread_name);
 
     const char *stop_reason = GetStopReasonString(tid_stop_info.reason);
     if (stop_reason)
       thread_obj.try_emplace("reason", stop_reason);
 
     if (!description.empty())
GDBRemoteCommunicationServerLLGS::PrepareStopReplyPacketForThread(
   //  "threads:10a,10b,10c;"
   // This will save the debugger from having to send a pair of qfThreadInfo and
   // qsThreadInfo packets, but it also might take a lot of room in the stop
   // reply packet, so it must be enabled only on systems where there are no
   // limits on packet lengths.
   if (m_list_threads_in_stop_reply) {
     response.PutCString("threads:");
 
-    uint32_t thread_index = 0;
-    NativeThreadProtocol *listed_thread;
-    for (listed_thread = process.GetThreadAtIndex(thread_index); listed_thread;
-         ++thread_index,
-        listed_thread = process.GetThreadAtIndex(thread_index)) {
-      if (thread_index > 0)
+    uint32_t thread_num = 0;
+    for (NativeThreadProtocol &listed_thread : process.Threads()) {
+      if (thread_num > 0)
         response.PutChar(',');
-      response.Printf("%" PRIx64, listed_thread->GetID());
+      response.Printf("%" PRIx64, listed_thread.GetID());
+      ++thread_num;
     }
     response.PutChar(';');
 
     // Include JSON info that describes the stop reason for any threads that
     // actually have stop reasons. We use the new "jstopinfo" key whose values
     // is hex ascii JSON that contains the thread IDs thread stop info only for
     // threads that have stop reasons. Only send this if we have more than one
     // thread otherwise this packet has all the info it needs.
-    if (thread_index > 1) {
+    if (thread_num > 1) {
       const bool threads_with_valid_stop_info_only = true;
       llvm::Expected<json::Array> threads_info = GetJSONThreadsInfo(
           *m_current_process, threads_with_valid_stop_info_only);
       if (threads_info) {
         response.PutCString("jstopinfo:");
         StreamString unescaped_response;
         unescaped_response.AsRawOstream() << std::move(*threads_info);
         response.PutStringAsRawHex8(unescaped_response.GetData());
         response.PutChar(';');
       } else {
         LLDB_LOG_ERROR(log, threads_info.takeError(),
                        "failed to prepare a jstopinfo field for pid {1}: {0}",
                        process.GetID());
       }
     }
 
-    uint32_t i = 0;
     response.PutCString("thread-pcs");
     char delimiter = ':';
-    for (NativeThreadProtocol *thread;
-         (thread = process.GetThreadAtIndex(i)) != nullptr; ++i) {
-      NativeRegisterContext &reg_ctx = thread->GetRegisterContext();
+    for (NativeThreadProtocol &thread : process.Threads()) {
+      NativeRegisterContext &reg_ctx = thread.GetRegisterContext();
 
       uint32_t reg_to_read = reg_ctx.ConvertRegisterKindToRegisterNumber(
           eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
       const RegisterInfo *const reg_info_p =
           reg_ctx.GetRegisterInfoAtIndex(reg_to_read);
 
       RegisterValue reg_value;
       Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread(
   return SendPacketNoLock(response.GetString());
 }
 
 void GDBRemoteCommunicationServerLLGS::EnqueueStopReplyPackets(
     lldb::tid_t thread_to_skip) {
   if (!m_non_stop)
     return;
 
-  uint32_t thread_index = 0;
-  while (NativeThreadProtocol *listed_thread =
-             m_current_process->GetThreadAtIndex(thread_index++)) {
-    if (listed_thread->GetID() != thread_to_skip)
+  for (NativeThreadProtocol &listed_thread : m_current_process->Threads()) {
+    if (listed_thread.GetID() != thread_to_skip)
       m_stop_notification_queue.push_back(
-          PrepareStopReplyPacketForThread(*listed_thread).GetString().str());
+          PrepareStopReplyPacketForThread(listed_thread).GetString().str());
   }
 }
 
 void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited(
     NativeProcessProtocol *process) {
   assert(process && "process cannot be NULL");
 
   Log *log = GetLog(LLDBLog::Process);
void GDBRemoteCommunicationServerLLGS::AddProcessThreads(
     StreamGDBRemote &response, NativeProcessProtocol &process, bool &had_any) {
   Log *log = GetLog(LLDBLog::Thread);
 
   lldb::pid_t pid = process.GetID();
   if (pid == LLDB_INVALID_PROCESS_ID)
     return;
 
   LLDB_LOG(log, "iterating over threads of process {0}", process.GetID());
-  NativeThreadProtocol *thread;
-  uint32_t thread_index;
-  for (thread_index = 0, thread = process.GetThreadAtIndex(thread_index);
-       thread;
-       ++thread_index, thread = process.GetThreadAtIndex(thread_index)) {
-    LLDB_LOG(log, "iterated thread {0} (tid={1})", thread_index,
-             thread->GetID());
+  for (NativeThreadProtocol &thread : process.Threads()) {
+    LLDB_LOG(log, "iterated thread tid={0}", thread.GetID());
     response.PutChar(had_any ? ',' : 'm');
-    AppendThreadIDToResponse(response, pid, thread->GetID());
+    AppendThreadIDToResponse(response, pid, thread.GetID());
     had_any = true;
   }
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo(
     StringExtractorGDBRemote &packet) {
   assert(m_debugged_processes.size() == 1 ||