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