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 eStopReasonSignal:
151             if (stop_info_sp->ShouldStop(event_ptr))
152             {
153                 if (log)
154                     log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (signal.)", m_thread.GetID());
155                 m_thread.DiscardThreadPlans(false);
156                 return true;
157             }
158             else
159             {
160                 // We're not going to stop, but while we are here, let's figure out
161                 // whether to report this.
162                  if (stop_info_sp->ShouldNotify(event_ptr))
163                     m_stop_vote = eVoteYes;
164                 else
165                     m_stop_vote = eVoteNo;
166             }
167             return false;
168 
169         default:
170             return true;
171         }
172 
173     }
174     else
175     {
176         m_run_vote = eVoteNoOpinion;
177         m_stop_vote = eVoteNo;
178     }
179 
180     // If there's no explicit reason to stop, then we will continue.
181     return false;
182 }
183 
184 bool
185 ThreadPlanBase::StopOthers ()
186 {
187     return false;
188 }
189 
190 StateType
191 ThreadPlanBase::GetPlanRunState ()
192 {
193     return eStateRunning;
194 }
195 
196 bool
197 ThreadPlanBase::WillStop ()
198 {
199     return true;
200 }
201 
202 bool
203 ThreadPlanBase::WillResume (lldb::StateType resume_state, bool current_plan)
204 {
205     // Reset these to the default values so we don't set them wrong, then not get asked
206     // for a while, then return the wrong answer.
207     m_run_vote = eVoteNoOpinion;
208     m_stop_vote = eVoteNo;
209     return true;
210 }
211 
212 
213 // The base plan is never done.
214 bool
215 ThreadPlanBase::MischiefManaged ()
216 {
217     // The base plan is never done.
218     return false;
219 }
220 
221