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
ThreadPlan(ThreadPlanKind kind,const char * name,Thread & thread,Vote report_stop_vote,Vote report_run_vote)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
GetTarget()37 Target &ThreadPlan::GetTarget() { return m_process.GetTarget(); }
38
GetTarget() const39 const Target &ThreadPlan::GetTarget() const { return m_process.GetTarget(); }
40
GetThread()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
PlanExplainsStop(Event * event_ptr)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
IsPlanComplete()60 bool ThreadPlan::IsPlanComplete() {
61 std::lock_guard<std::recursive_mutex> guard(m_plan_complete_mutex);
62 return m_plan_complete;
63 }
64
SetPlanComplete(bool success)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
MischiefManaged()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
ShouldReportStop(Event * event_ptr)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
ShouldReportRun(Event * event_ptr)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
ClearThreadCache()102 void ThreadPlan::ClearThreadCache() { m_thread = nullptr; }
103
StopOthers()104 bool ThreadPlan::StopOthers() {
105 ThreadPlan *prev_plan;
106 prev_plan = GetPreviousPlan();
107 return (prev_plan == nullptr) ? false : prev_plan->StopOthers();
108 }
109
SetStopOthers(bool new_value)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
WillResume(StateType resume_state,bool current_plan)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
GetNextID()145 lldb::user_id_t ThreadPlan::GetNextID() {
146 static uint32_t g_nextPlanID = 0;
147 return ++g_nextPlanID;
148 }
149
DidPush()150 void ThreadPlan::DidPush() {}
151
DidPop()152 void ThreadPlan::DidPop() {}
153
OkayToDiscard()154 bool ThreadPlan::OkayToDiscard() {
155 return IsMasterPlan() ? m_okay_to_discard : true;
156 }
157
RunState()158 lldb::StateType ThreadPlan::RunState() {
159 if (m_tracer_sp && m_tracer_sp->TracingEnabled())
160 return eStateStepping;
161 else
162 return GetPlanRunState();
163 }
164
IsUsuallyUnexplainedStopReason(lldb::StopReason reason)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
ThreadPlanNull(Thread & thread)181 ThreadPlanNull::ThreadPlanNull(Thread &thread)
182 : ThreadPlan(ThreadPlan::eKindNull, "Null Thread Plan", thread,
183 eVoteNoOpinion, eVoteNoOpinion) {}
184
185 ThreadPlanNull::~ThreadPlanNull() = default;
186
GetDescription(Stream * s,lldb::DescriptionLevel level)187 void ThreadPlanNull::GetDescription(Stream *s, lldb::DescriptionLevel level) {
188 s->PutCString("Null thread plan - thread has been destroyed.");
189 }
190
ValidatePlan(Stream * error)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
ShouldStop(Event * event_ptr)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
WillStop()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
DoPlanExplainsStop(Event * event_ptr)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.
MischiefManaged()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
GetPlanRunState()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