Add a mutex to the ThreadPlanStackMap class.

We've seen very occasional crashes that we can only explain by
simultaneous access to the ThreadPlanStackMap, so I'm adding a
mutex to protect it.

Differential Revision: https://reviews.llvm.org/D124029

Author: jimingham

lldb/include/lldb/Target/ThreadPlanStack.h

@@ -132,6 +132,7 @@ class ThreadPlanStackMap {
               bool check_for_new = true);
 
   void AddThread(Thread &thread) {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     lldb::tid_t tid = thread.GetID();
     // If we already have a ThreadPlanStack for this thread, use it.
     if (m_plans_list.find(tid) != m_plans_list.end())
@@ -143,6 +144,7 @@ class ThreadPlanStackMap {
   }
 
   bool RemoveTID(lldb::tid_t tid) {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     auto result = m_plans_list.find(tid);
     if (result == m_plans_list.end())
       return false;
@@ -165,6 +167,7 @@ class ThreadPlanStackMap {
   }
 
   ThreadPlanStack *Find(lldb::tid_t tid) {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     auto result = m_plans_list.find(tid);
     if (result == m_plans_list.end())
       return nullptr;
@@ -177,12 +180,14 @@ class ThreadPlanStackMap {
   /// This is useful in situations like when a new Thread list is being
   /// generated.
   void ClearThreadCache() {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     for (auto &plan_list : m_plans_list)
       plan_list.second->ClearThreadCache();
   }
 
   // rename to Reactivate?
   void Activate(ThreadPlanStack &stack) {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     // Remove this from the detached plan list:
     auto end = m_detached_plans.end();    
     auto iter = std::find_if(m_detached_plans.begin(), end, 
@@ -198,6 +203,7 @@ class ThreadPlanStackMap {
   }
 
   void ScanForDetachedPlanStacks() {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     llvm::SmallVector<lldb::tid_t, 2> invalidated_tids;
     for (auto &pair : m_plans_list)
       if (pair.second->GetTID() != pair.first)
@@ -217,10 +223,12 @@ class ThreadPlanStackMap {
   // scheduled.
   // The vector will never have null ThreadPlanStacks in it.
   std::vector<ThreadPlanStack *> &GetDetachedPlanStacks() {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     return m_detached_plans;
   }
 
   void Clear() {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     for (auto &plan : m_plans_list)
       plan.second->ThreadDestroyed(nullptr);
     m_plans_list.clear();
@@ -255,6 +263,7 @@ class ThreadPlanStackMap {
   PlansStore m_plans_up_container;
   std::vector<ThreadPlanStack *> m_detached_plans;
 
+  mutable std::recursive_mutex m_stack_map_mutex;
   using PlansList = std::unordered_map<lldb::tid_t, ThreadPlanStack *>;
   PlansList m_plans_list;
 };

lldb/source/Target/ThreadPlanStack.cpp

@@ -411,6 +411,7 @@ void ThreadPlanStackMap::Update(ThreadList &current_threads,
                                 bool delete_missing,
                                 bool check_for_new) {
 
+  std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
   // Now find all the new threads and add them to the map:
   if (check_for_new) {
     for (auto thread : current_threads.Threads()) {
@@ -445,6 +446,7 @@ void ThreadPlanStackMap::DumpPlans(Stream &strm,
                                    lldb::DescriptionLevel desc_level,
                                    bool internal, bool condense_if_trivial,
                                    bool skip_unreported) {
+  std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
   for (auto &elem : m_plans_list) {
     lldb::tid_t tid = elem.first;
     uint32_t index_id = 0;
@@ -481,6 +483,7 @@ bool ThreadPlanStackMap::DumpPlansForTID(Stream &strm, lldb::tid_t tid,
                                          bool internal,
                                          bool condense_if_trivial,
                                          bool skip_unreported) {
+  std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
   uint32_t index_id = 0;
   ThreadSP thread_sp = m_process.GetThreadList().FindThreadByID(tid);
 
@@ -520,6 +523,7 @@ bool ThreadPlanStackMap::DumpPlansForTID(Stream &strm, lldb::tid_t tid,
 
 bool ThreadPlanStackMap::PrunePlansForTID(lldb::tid_t tid) {
   // We only remove the plans for unreported TID's.
+  std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
   ThreadSP thread_sp = m_process.GetThreadList().FindThreadByID(tid);
   if (thread_sp)
     return false;