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