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