Merge pull request #9945 from felipepiovezan/felipe/cherrypick_stop_reason_fixes

[cherry-pick] Fixes for StopReason propagation in the presence of OS plugins

Author: felipepiovezan

lldb/include/lldb/Target/Thread.h

@@ -465,6 +465,26 @@ class Thread : public std::enable_shared_from_this<Thread>,
 
   virtual void ClearStackFrames();
 
+  /// Sets the thread that is backed by this thread.
+  /// If backed_thread.GetBackedThread() is null, this method also calls
+  /// backed_thread.SetBackingThread(this).
+  /// If backed_thread.GetBackedThread() is non-null, asserts that it is equal
+  /// to `this`.
+  void SetBackedThread(Thread &backed_thread) {
+    m_backed_thread = backed_thread.shared_from_this();
+
+    // Ensure the bidrectional relationship is preserved.
+    Thread *backing_thread = backed_thread.GetBackingThread().get();
+    assert(backing_thread == nullptr || backing_thread == this);
+    if (backing_thread == nullptr)
+      backed_thread.SetBackingThread(shared_from_this());
+  }
+
+  void ClearBackedThread() { m_backed_thread.reset(); }
+
+  /// Returns the thread that is backed by this thread, if any.
+  lldb::ThreadSP GetBackedThread() const { return m_backed_thread.lock(); }
+
   virtual bool SetBackingThread(const lldb::ThreadSP &thread_sp) {
     return false;
   }
@@ -1376,6 +1396,9 @@ class Thread : public std::enable_shared_from_this<Thread>,
   LazyBool m_override_should_notify;
   mutable std::unique_ptr<ThreadPlanStack> m_null_plan_stack_up;
 
+  /// The Thread backed by this thread, if any.
+  lldb::ThreadWP m_backed_thread;
+
 private:
   bool m_extended_info_fetched; // Have we tried to retrieve the m_extended_info
                                 // for this thread?

lldb/include/lldb/Target/ThreadList.h

@@ -101,8 +101,6 @@ class ThreadList : public ThreadCollection {
 
   lldb::ThreadSP GetThreadSPForThreadPtr(Thread *thread_ptr);
 
-  lldb::ThreadSP GetBackingThread(const lldb::ThreadSP &real_thread);
-
   bool ShouldStop(Event *event_ptr);
 
   Vote ShouldReportStop(Event *event_ptr);

lldb/source/Breakpoint/BreakpointSite.cpp

@@ -12,6 +12,7 @@
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
+#include "lldb/Target/Thread.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
@@ -161,6 +162,8 @@ BreakpointLocationSP BreakpointSite::GetConstituentAtIndex(size_t index) {
 
 bool BreakpointSite::ValidForThisThread(Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
+  if (ThreadSP backed_thread = thread.GetBackedThread())
+    return m_constituents.ValidForThisThread(*backed_thread);
   return m_constituents.ValidForThisThread(thread);
 }
 

lldb/source/Plugins/Process/Utility/ThreadMemory.h

@@ -72,12 +72,17 @@ class ThreadMemory : public lldb_private::Thread {
 
   void ClearStackFrames() override;
 
-  void ClearBackingThread() override { m_backing_thread_sp.reset(); }
+  void ClearBackingThread() override {
+    if (m_backing_thread_sp)
+      m_backing_thread_sp->ClearBackedThread();
+    m_backing_thread_sp.reset();
+  }
 
   bool SetBackingThread(const lldb::ThreadSP &thread_sp) override {
     // printf ("Thread 0x%llx is being backed by thread 0x%llx\n", GetID(),
     // thread_sp->GetID());
     m_backing_thread_sp = thread_sp;
+    thread_sp->SetBackedThread(*this);
     return (bool)thread_sp;
   }
 

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

@@ -1726,10 +1726,6 @@ ThreadSP ProcessGDBRemote::SetThreadStopInfo(
 
   if (!thread_sp->StopInfoIsUpToDate()) {
     thread_sp->SetStopInfo(StopInfoSP());
-    // If there's a memory thread backed by this thread, we need to use it to
-    // calculate StopInfo.
-    if (ThreadSP memory_thread_sp = m_thread_list.GetBackingThread(thread_sp))
-      thread_sp = memory_thread_sp;
 
     if (exc_type != 0) {
       const size_t exc_data_size = exc_data.size();

lldb/source/Target/ThreadList.cpp

@@ -191,20 +191,6 @@ ThreadSP ThreadList::GetThreadSPForThreadPtr(Thread *thread_ptr) {
   return thread_sp;
 }
 
-ThreadSP ThreadList::GetBackingThread(const ThreadSP &real_thread) {
-  std::lock_guard<std::recursive_mutex> guard(GetMutex());
-
-  ThreadSP thread_sp;
-  const uint32_t num_threads = m_threads.size();
-  for (uint32_t idx = 0; idx < num_threads; ++idx) {
-    if (m_threads[idx]->GetBackingThread() == real_thread) {
-      thread_sp = m_threads[idx];
-      break;
-    }
-  }
-  return thread_sp;
-}
-
 ThreadSP ThreadList::FindThreadByIndexID(uint32_t index_id, bool can_update) {
   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 

lldb/unittests/OperatingSystem/CMakeLists.txt

@@ -0,0 +1,21 @@
+add_lldb_unittest(ProcessGdbRemoteTests
+  GDBRemoteClientBaseTest.cpp
+  GDBRemoteCommunicationClientTest.cpp
+  GDBRemoteCommunicationServerLLGSTest.cpp
+  GDBRemoteCommunicationServerTest.cpp
+  GDBRemoteCommunicationTest.cpp
+  GDBRemoteTestUtils.cpp
+
+  LINK_LIBS
+    LLVMTestingSupport
+    lldbCore
+    lldbHost
+    lldbInterpreter
+    lldbPluginProcessUtility
+    lldbSymbol
+    lldbTarget
+    lldbValueObject
+
+  LINK_COMPONENTS
+    Support
+  )

lldb/unittests/OperatingSystem/OperatingSystemPlugin.h

@@ -0,0 +1,59 @@
+//===-- OperatingSystemPlugin.h ---------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Target/OperatingSystem.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Target/ThreadList.h"
+
+/// An operating system plugin that does nothing: simply keeps the thread lists
+/// as they are.
+class OperatingSystemIdentityMap : public lldb_private::OperatingSystem {
+public:
+  OperatingSystemIdentityMap(lldb_private::Process *process)
+      : OperatingSystem(process) {}
+
+  static OperatingSystem *CreateInstance(lldb_private::Process *process,
+                                         bool force) {
+    return new OperatingSystemIdentityMap(process);
+  }
+  static llvm::StringRef GetPluginNameStatic() { return "identity map"; }
+  static llvm::StringRef GetPluginDescriptionStatic() { return ""; }
+
+  static void Initialize() {
+    lldb_private::PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                                GetPluginDescriptionStatic(),
+                                                CreateInstance, nullptr);
+  }
+  static void Terminate() {
+    lldb_private::PluginManager::UnregisterPlugin(CreateInstance);
+  }
+  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
+
+  // Simply adds the threads from real_thread_list into new_thread_list.
+  bool UpdateThreadList(lldb_private::ThreadList &old_thread_list,
+                        lldb_private::ThreadList &real_thread_list,
+                        lldb_private::ThreadList &new_thread_list) override {
+    for (const auto &real_thread : real_thread_list.Threads())
+      new_thread_list.AddThread(real_thread);
+    return true;
+  }
+
+  void ThreadWasSelected(lldb_private::Thread *thread) override {}
+
+  lldb::RegisterContextSP
+  CreateRegisterContextForThread(lldb_private::Thread *thread,
+                                 lldb::addr_t reg_data_addr) override {
+    return thread->GetRegisterContext();
+  }
+
+  lldb::StopInfoSP
+  CreateThreadStopReason(lldb_private::Thread *thread) override {
+    return thread->GetStopInfo();
+  }
+};

lldb/unittests/OperatingSystem/TestThreadSpecificBreakpoints.cpp

@@ -0,0 +1,10 @@
+//===-- OperatingSystemPlugin.h ---------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "OperatingSystemPlugin.h"
+LLDB_PLUGIN_DEFINE(OperatingSystemIdentityMap)