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