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