contrib/llvm/tools/lldb/source/Target/ThreadPlan.cpp

   1 //===-- ThreadPlan.cpp ------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Target/ThreadPlan.h"
  11 #include "lldb/Core/Debugger.h"
  12 #include "lldb/Target/Process.h"
  13 #include "lldb/Target/RegisterContext.h"
  14 #include "lldb/Target/Target.h"
  15 #include "lldb/Target/Thread.h"
  16 #include "lldb/Utility/Log.h"
  17 #include "lldb/Utility/State.h"
  18
  19 using namespace lldb;
  20 using namespace lldb_private;
  21
  22 //----------------------------------------------------------------------
  23 // ThreadPlan constructor
  24 //----------------------------------------------------------------------
  25 ThreadPlan::ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread,
  26                        Vote stop_vote, Vote run_vote)
  27     : m_thread(thread), m_stop_vote(stop_vote), m_run_vote(run_vote),
  28       m_takes_iteration_count(false), m_could_not_resolve_hw_bp(false),
  29       m_kind(kind), m_name(name), m_plan_complete_mutex(),
  30       m_cached_plan_explains_stop(eLazyBoolCalculate), m_plan_complete(false),
  31       m_plan_private(false), m_okay_to_discard(true), m_is_master_plan(false),
  32       m_plan_succeeded(true) {
  33   SetID(GetNextID());
  34 }
  35
  36 //----------------------------------------------------------------------
  37 // Destructor
  38 //----------------------------------------------------------------------
  39 ThreadPlan::~ThreadPlan() = default;
  40
  41 bool ThreadPlan::PlanExplainsStop(Event *event_ptr) {
  42   if (m_cached_plan_explains_stop == eLazyBoolCalculate) {
  43     bool actual_value = DoPlanExplainsStop(event_ptr);
  44     m_cached_plan_explains_stop = actual_value ? eLazyBoolYes : eLazyBoolNo;
  45     return actual_value;
  46   } else {
  47     return m_cached_plan_explains_stop == eLazyBoolYes;
  48   }
  49 }
  50
  51 bool ThreadPlan::IsPlanComplete() {
  52   std::lock_guard<std::recursive_mutex> guard(m_plan_complete_mutex);
  53   return m_plan_complete;
  54 }
  55
  56 void ThreadPlan::SetPlanComplete(bool success) {
  57   std::lock_guard<std::recursive_mutex> guard(m_plan_complete_mutex);
  58   m_plan_complete = true;
  59   m_plan_succeeded = success;
  60 }
  61
  62 bool ThreadPlan::MischiefManaged() {
  63   std::lock_guard<std::recursive_mutex> guard(m_plan_complete_mutex);
  64   // Mark the plan is complete, but don't override the success flag.
  65   m_plan_complete = true;
  66   return true;
  67 }
  68
  69 Vote ThreadPlan::ShouldReportStop(Event *event_ptr) {
  70   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
  71
  72   if (m_stop_vote == eVoteNoOpinion) {
  73     ThreadPlan *prev_plan = GetPreviousPlan();
  74     if (prev_plan) {
  75       Vote prev_vote = prev_plan->ShouldReportStop(event_ptr);
  76       LLDB_LOG(log, "returning previous thread plan vote: {0}", prev_vote);
  77       return prev_vote;
  78     }
  79   }
  80   LLDB_LOG(log, "Returning vote: {0}", m_stop_vote);
  81   return m_stop_vote;
  82 }
  83
  84 Vote ThreadPlan::ShouldReportRun(Event *event_ptr) {
  85   if (m_run_vote == eVoteNoOpinion) {
  86     ThreadPlan *prev_plan = GetPreviousPlan();
  87     if (prev_plan)
  88       return prev_plan->ShouldReportRun(event_ptr);
  89   }
  90   return m_run_vote;
  91 }
  92
  93 bool ThreadPlan::StopOthers() {
  94   ThreadPlan *prev_plan;
  95   prev_plan = GetPreviousPlan();
  96   return (prev_plan == nullptr) ? false : prev_plan->StopOthers();
  97 }
  98
  99 void ThreadPlan::SetStopOthers(bool new_value) {
 100   // SetStopOthers doesn't work up the hierarchy.  You have to set the explicit
 101   // ThreadPlan you want to affect.
 102 }
 103
 104 bool ThreadPlan::WillResume(StateType resume_state, bool current_plan) {
 105   m_cached_plan_explains_stop = eLazyBoolCalculate;
 106
 107   if (current_plan) {
 108     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 109
 110     if (log) {
 111       RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
 112       assert(reg_ctx);
 113       addr_t pc = reg_ctx->GetPC();
 114       addr_t sp = reg_ctx->GetSP();
 115       addr_t fp = reg_ctx->GetFP();
 116       log->Printf(
 117           "%s Thread #%u (0x%p): tid = 0x%4.4" PRIx64 ", pc = 0x%8.8" PRIx64
 118           ", sp = 0x%8.8" PRIx64 ", fp = 0x%8.8" PRIx64 ", "
 119           "plan = '%s', state = %s, stop others = %d",
 120           __FUNCTION__, m_thread.GetIndexID(), static_cast<void *>(&m_thread),
 121           m_thread.GetID(), static_cast<uint64_t>(pc),
 122           static_cast<uint64_t>(sp), static_cast<uint64_t>(fp), m_name.c_str(),
 123           StateAsCString(resume_state), StopOthers());
 124     }
 125   }
 126   return DoWillResume(resume_state, current_plan);
 127 }
 128
 129 lldb::user_id_t ThreadPlan::GetNextID() {
 130   static uint32_t g_nextPlanID = 0;
 131   return ++g_nextPlanID;
 132 }
 133
 134 void ThreadPlan::DidPush() {}
 135
 136 void ThreadPlan::WillPop() {}
 137
 138 bool ThreadPlan::OkayToDiscard() {
 139   return IsMasterPlan() ? m_okay_to_discard : true;
 140 }
 141
 142 lldb::StateType ThreadPlan::RunState() {
 143   if (m_tracer_sp && m_tracer_sp->TracingEnabled() &&
 144       m_tracer_sp->SingleStepEnabled())
 145     return eStateStepping;
 146   else
 147     return GetPlanRunState();
 148 }
 149
 150 bool ThreadPlan::IsUsuallyUnexplainedStopReason(lldb::StopReason reason) {
 151   switch (reason) {
 152   case eStopReasonWatchpoint:
 153   case eStopReasonSignal:
 154   case eStopReasonException:
 155   case eStopReasonExec:
 156   case eStopReasonThreadExiting:
 157   case eStopReasonInstrumentation:
 158     return true;
 159   default:
 160     return false;
 161   }
 162 }
 163
 164 //----------------------------------------------------------------------
 165 // ThreadPlanNull
 166 //----------------------------------------------------------------------
 167
 168 ThreadPlanNull::ThreadPlanNull(Thread &thread)
 169     : ThreadPlan(ThreadPlan::eKindNull, "Null Thread Plan", thread,
 170                  eVoteNoOpinion, eVoteNoOpinion) {}
 171
 172 ThreadPlanNull::~ThreadPlanNull() = default;
 173
 174 void ThreadPlanNull::GetDescription(Stream *s, lldb::DescriptionLevel level) {
 175   s->PutCString("Null thread plan - thread has been destroyed.");
 176 }
 177
 178 bool ThreadPlanNull::ValidatePlan(Stream *error) {
 179 #ifdef LLDB_CONFIGURATION_DEBUG
 180   fprintf(stderr,
 181           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
 182           ", ptid = 0x%" PRIx64 ")",
 183           LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
 184 #else
 185   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 186   if (log)
 187     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
 188                ", ptid = 0x%" PRIx64 ")",
 189                LLVM_PRETTY_FUNCTION, m_thread.GetID(),
 190                m_thread.GetProtocolID());
 191 #endif
 192   return true;
 193 }
 194
 195 bool ThreadPlanNull::ShouldStop(Event *event_ptr) {
 196 #ifdef LLDB_CONFIGURATION_DEBUG
 197   fprintf(stderr,
 198           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
 199           ", ptid = 0x%" PRIx64 ")",
 200           LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
 201 #else
 202   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 203   if (log)
 204     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
 205                ", ptid = 0x%" PRIx64 ")",
 206                LLVM_PRETTY_FUNCTION, m_thread.GetID(),
 207                m_thread.GetProtocolID());
 208 #endif
 209   return true;
 210 }
 211
 212 bool ThreadPlanNull::WillStop() {
 213 #ifdef LLDB_CONFIGURATION_DEBUG
 214   fprintf(stderr,
 215           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
 216           ", ptid = 0x%" PRIx64 ")",
 217           LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
 218 #else
 219   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 220   if (log)
 221     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
 222                ", ptid = 0x%" PRIx64 ")",
 223                LLVM_PRETTY_FUNCTION, m_thread.GetID(),
 224                m_thread.GetProtocolID());
 225 #endif
 226   return true;
 227 }
 228
 229 bool ThreadPlanNull::DoPlanExplainsStop(Event *event_ptr) {
 230 #ifdef LLDB_CONFIGURATION_DEBUG
 231   fprintf(stderr,
 232           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
 233           ", ptid = 0x%" PRIx64 ")",
 234           LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
 235 #else
 236   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 237   if (log)
 238     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
 239                ", ptid = 0x%" PRIx64 ")",
 240                LLVM_PRETTY_FUNCTION, m_thread.GetID(),
 241                m_thread.GetProtocolID());
 242 #endif
 243   return true;
 244 }
 245
 246 // The null plan is never done.
 247 bool ThreadPlanNull::MischiefManaged() {
 248 // The null plan is never done.
 249 #ifdef LLDB_CONFIGURATION_DEBUG
 250   fprintf(stderr,
 251           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
 252           ", ptid = 0x%" PRIx64 ")",
 253           LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
 254 #else
 255   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 256   if (log)
 257     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
 258                ", ptid = 0x%" PRIx64 ")",
 259                LLVM_PRETTY_FUNCTION, m_thread.GetID(),
 260                m_thread.GetProtocolID());
 261 #endif
 262   return false;
 263 }
 264
 265 lldb::StateType ThreadPlanNull::GetPlanRunState() {
 266 // Not sure what to return here.  This is a dead thread.
 267 #ifdef LLDB_CONFIGURATION_DEBUG
 268   fprintf(stderr,
 269           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
 270           ", ptid = 0x%" PRIx64 ")",
 271           LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
 272 #else
 273   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 274   if (log)
 275     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
 276                ", ptid = 0x%" PRIx64 ")",
 277                LLVM_PRETTY_FUNCTION, m_thread.GetID(),
 278                m_thread.GetProtocolID());
 279 #endif
 280   return eStateRunning;
 281 }