ThreadPlanStack.h

Go to the documentation of this file.

//===-- ThreadPlanStack.h ---------------------------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
 
#ifndef LLDB_TARGET_THREADPLANSTACK_H
#define LLDB_TARGET_THREADPLANSTACK_H
 
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "llvm/Support/RWMutex.h"
 
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/lldb-private-forward.h"
#include "lldb/lldb-private.h"
 
namespace lldb_private {
 
// The ThreadPlans have a thread for use when they are asked all the ThreadPlan
// state machine questions, but they should never cache any pointers from their
// owning lldb_private::Thread.  That's because we want to be able to detach
// them from an owning thread, then reattach them by TID.
// The ThreadPlanStack holds the ThreadPlans for a given TID.  All its methods
// are private, and it should only be accessed through the owning thread.  When
// it is detached from a thread, all you can do is reattach it or delete it.
class ThreadPlanStack {
  friend class lldb_private::Thread;
 
public:
  ThreadPlanStack(const Thread &thread, bool make_empty = false);
  ~ThreadPlanStack() = default;
 
  using PlanStack = std::vector<lldb::ThreadPlanSP>;
 
  void DumpThreadPlans(Stream &s, lldb::DescriptionLevel desc_level,
                       bool include_internal) const;
 
  size_t CheckpointCompletedPlans();
 
  void RestoreCompletedPlanCheckpoint(size_t checkpoint);
 
  void DiscardCompletedPlanCheckpoint(size_t checkpoint);
 
  void ThreadDestroyed(Thread *thread);
 
  void PushPlan(lldb::ThreadPlanSP new_plan_sp);
 
  lldb::ThreadPlanSP PopPlan();
 
  lldb::ThreadPlanSP DiscardPlan();
 
  // If the input plan is nullptr, discard all plans.  Otherwise make sure this
  // plan is in the stack, and if so discard up to and including it.
  void DiscardPlansUpToPlan(ThreadPlan *up_to_plan_ptr);
 
  void DiscardAllPlans();
 
  void DiscardConsultingControllingPlans();
 
  lldb::ThreadPlanSP GetCurrentPlan() const;
 
  lldb::ThreadPlanSP GetCompletedPlan(bool skip_private = true) const;
 
  lldb::ThreadPlanSP GetPlanByIndex(uint32_t plan_idx,
                                    bool skip_private = true) const;
 
  lldb::ValueObjectSP GetReturnValueObject() const;
 
  lldb::ExpressionVariableSP GetExpressionVariable() const;
 
  bool AnyPlans() const;
 
  bool AnyCompletedPlans() const;
 
  bool AnyDiscardedPlans() const;
 
  bool IsPlanDone(ThreadPlan *plan) const;
 
  bool WasPlanDiscarded(ThreadPlan *plan) const;
 
  ThreadPlan *GetPreviousPlan(ThreadPlan *current_plan) const;
 
  ThreadPlan *GetInnermostExpression() const;
 
  void WillResume();
 
  /// Clear the Thread* cache that each ThreadPlan contains.
  ///
  /// This is useful in situations like when a new Thread list is being
  /// generated.
  void ClearThreadCache();
 
private:
  lldb::ThreadPlanSP DiscardPlanNoLock();
  lldb::ThreadPlanSP GetCurrentPlanNoLock() const;
  void PrintOneStackNoLock(Stream &s, llvm::StringRef stack_name,
                           const PlanStack &stack,
                           lldb::DescriptionLevel desc_level,
                           bool include_internal) const;
 
  PlanStack m_plans;           ///< The stack of plans this thread is executing.
  PlanStack m_completed_plans; ///< Plans that have been completed by this
                               /// stop.  They get deleted when the thread
                               /// resumes.
  PlanStack m_discarded_plans; ///< Plans that have been discarded by this
                               /// stop.  They get deleted when the thread
                               /// resumes.
  size_t m_completed_plan_checkpoint = 0; // Monotonically increasing token for
                                          // completed plan checkpoints.
  std::unordered_map<size_t, PlanStack> m_completed_plan_store;
  mutable llvm::sys::RWMutex m_stack_mutex;
};
 
class ThreadPlanStackMap {
public:
  ThreadPlanStackMap(Process &process) : m_process(process) {}
  ~ThreadPlanStackMap() = default;
 
  // Prune the map using the current_threads list.
  void Update(ThreadList &current_threads, bool delete_missing,
              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();
    m_plans_list.emplace(tid, thread);
  }
 
  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;
    result->second.ThreadDestroyed(nullptr);
    m_plans_list.erase(result);
    return true;
  }
 
  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;
    else
      return &result->second;
  }
 
  /// Clear the Thread* cache that each ThreadPlan contains.
  ///
  /// This is useful in situations like when a new Thread list is being
  /// generated.
  void ClearThreadCache() {
    for (auto &plan_list : m_plans_list)
      plan_list.second.ClearThreadCache();
  }
 
  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();
  }
 
  // Implements Process::DumpThreadPlans
  void DumpPlans(Stream &strm, lldb::DescriptionLevel desc_level, bool internal,
                 bool ignore_boring, bool skip_unreported);
 
  // Implements Process::DumpThreadPlansForTID
  bool DumpPlansForTID(Stream &strm, lldb::tid_t tid,
                       lldb::DescriptionLevel desc_level, bool internal,
                       bool ignore_boring, bool skip_unreported);
                       
  bool PrunePlansForTID(lldb::tid_t tid);
 
private:
  Process &m_process;
  mutable std::recursive_mutex m_stack_map_mutex;
  using PlansList = std::unordered_map<lldb::tid_t, ThreadPlanStack>;
  PlansList m_plans_list;
  
};
 
} // namespace lldb_private
 
#endif // LLDB_TARGET_THREADPLANSTACK_H