1 //===-- ThreadPlanBase.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/Target/ThreadPlanBase.h"
11 
12 // C Includes
13 // C++ Includes
14 // Other libraries and framework includes
15 // Project includes
16 //
17 #include "lldb/Breakpoint/StoppointCallbackContext.h"
18 #include "lldb/Breakpoint/BreakpointSite.h"
19 #include "lldb/Breakpoint/BreakpointLocation.h"
20 #include "lldb/Breakpoint/Breakpoint.h"
21 #include "lldb/Core/Log.h"
22 #include "lldb/Core/Stream.h"
23 #include "lldb/Target/Process.h"
24 #include "lldb/Target/RegisterContext.h"
25 #include "lldb/Target/StopInfo.h"
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 //----------------------------------------------------------------------
31 // ThreadPlanBase: This one always stops, and never has anything particular
32 // to do.
33 // FIXME: The "signal handling" policies should probably go here.
34 //----------------------------------------------------------------------
35 
36 ThreadPlanBase::ThreadPlanBase (Thread &thread) :
37     ThreadPlan(ThreadPlan::eKindBase, "base plan", thread, eVoteYes, eVoteNoOpinion)
38 {
39     // Set the tracer to a default tracer.
40     // FIXME: need to add a thread settings variable to pix various tracers...
41 #define THREAD_PLAN_USE_ASSEMBLY_TRACER 1
42 
43 #ifdef THREAD_PLAN_USE_ASSEMBLY_TRACER
44     ThreadPlanTracerSP new_tracer_sp (new ThreadPlanAssemblyTracer (m_thread));
45 #else
46     ThreadPlanTracerSP new_tracer_sp (new ThreadPlanTracer (m_thread));
47 #endif
48     new_tracer_sp->EnableTracing (m_thread.GetTraceEnabledState());
49     SetThreadPlanTracer(new_tracer_sp);
50     SetIsMasterPlan (true);
51 }
52 
53 ThreadPlanBase::~ThreadPlanBase ()
54 {
55 
56 }
57 
58 void
59 ThreadPlanBase::GetDescription (Stream *s, lldb::DescriptionLevel level)
60 {
61     s->Printf ("Base thread plan.");
62 }
63 
64 bool
65 ThreadPlanBase::ValidatePlan (Stream *error)
66 {
67     return true;
68 }
69 
70 bool
71 ThreadPlanBase::PlanExplainsStop ()
72 {
73     // The base plan should defer to its tracer, since by default it
74     // always handles the stop.
75     if (TracerExplainsStop())
76         return false;
77     else
78         return true;
79 }
80 
81 bool
82 ThreadPlanBase::ShouldStop (Event *event_ptr)
83 {
84     m_stop_vote = eVoteYes;
85     m_run_vote = eVoteYes;
86 
87     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
88 
89     StopInfoSP stop_info_sp = GetPrivateStopReason();
90     if (stop_info_sp)
91     {
92         StopReason reason = stop_info_sp->GetStopReason();
93         switch (reason)
94         {
95         case eStopReasonInvalid:
96         case eStopReasonNone:
97             // This
98             m_run_vote = eVoteNoOpinion;
99             m_stop_vote = eVoteNo;
100             return false;
101 
102         case eStopReasonBreakpoint:
103         case eStopReasonWatchpoint:
104             if (stop_info_sp->ShouldStop(event_ptr))
105             {
106                 // If we are going to stop for a breakpoint, then unship the other plans
107                 // at this point.  Don't force the discard, however, so Master plans can stay
108                 // in place if they want to.
109                 if (log)
110                     log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (breakpoint hit.)", m_thread.GetID());
111                 m_thread.DiscardThreadPlans(false);
112                 return true;
113             }
114             // If we aren't going to stop at this breakpoint, and it is internal,
115             // don't report this stop or the subsequent running event.
116             // Otherwise we will post the stopped & running, but the stopped event will get marked
117             // with "restarted" so the UI will know to wait and expect the consequent "running".
118             if (stop_info_sp->ShouldNotify (event_ptr))
119             {
120                 m_stop_vote = eVoteYes;
121                 m_run_vote = eVoteYes;
122             }
123             else
124             {
125                 m_stop_vote = eVoteNo;
126                 m_run_vote = eVoteNo;
127             }
128             return false;
129 
130             // TODO: the break below was missing, was this intentional??? If so
131             // please mention it
132             break;
133 
134         case eStopReasonException:
135             // If we crashed, discard thread plans and stop.  Don't force the discard, however,
136             // since on rerun the target may clean up this exception and continue normally from there.
137                 if (log)
138                     log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (exception.)", m_thread.GetID());
139             m_thread.DiscardThreadPlans(false);
140             return true;
141 
142         case eStopReasonExec:
143             // If we crashed, discard thread plans and stop.  Don't force the discard, however,
144             // since on rerun the target may clean up this exception and continue normally from there.
145             if (log)
146                 log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (exec.)", m_thread.GetID());
147             m_thread.DiscardThreadPlans(false);
148             return true;
149 
150         case eStopReasonThreadExiting:
151         case eStopReasonSignal:
152             if (stop_info_sp->ShouldStop(event_ptr))
153             {
154                 if (log)
155                     log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (signal.)", m_thread.GetID());
156                 m_thread.DiscardThreadPlans(false);
157                 return true;
158             }
159             else
160             {
161                 // We're not going to stop, but while we are here, let's figure out
162                 // whether to report this.
163                  if (stop_info_sp->ShouldNotify(event_ptr))
164                     m_stop_vote = eVoteYes;
165                 else
166                     m_stop_vote = eVoteNo;
167             }
168             return false;
169 
170         default:
171             return true;
172         }
173 
174     }
175     else
176     {
177         m_run_vote = eVoteNoOpinion;
178         m_stop_vote = eVoteNo;
179     }
180 
181     // If there's no explicit reason to stop, then we will continue.
182     return false;
183 }
184 
185 bool
186 ThreadPlanBase::StopOthers ()
187 {
188     return false;
189 }
190 
191 StateType
192 ThreadPlanBase::GetPlanRunState ()
193 {
194     return eStateRunning;
195 }
196 
197 bool
198 ThreadPlanBase::WillStop ()
199 {
200     return true;
201 }
202 
203 bool
204 ThreadPlanBase::WillResume (lldb::StateType resume_state, bool current_plan)
205 {
206     // Reset these to the default values so we don't set them wrong, then not get asked
207     // for a while, then return the wrong answer.
208     m_run_vote = eVoteNoOpinion;
209     m_stop_vote = eVoteNo;
210     return true;
211 }
212 
213 
214 // The base plan is never done.
215 bool
216 ThreadPlanBase::MischiefManaged ()
217 {
218     // The base plan is never done.
219     return false;
220 }
221 
222