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
ThreadPlanBase(Thread & thread)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
~ThreadPlanBase()53 ThreadPlanBase::~ThreadPlanBase ()
54 {
55
56 }
57
58 void
GetDescription(Stream * s,lldb::DescriptionLevel level)59 ThreadPlanBase::GetDescription (Stream *s, lldb::DescriptionLevel level)
60 {
61 s->Printf ("Base thread plan.");
62 }
63
64 bool
ValidatePlan(Stream * error)65 ThreadPlanBase::ValidatePlan (Stream *error)
66 {
67 return true;
68 }
69
70 bool
DoPlanExplainsStop(Event * event_ptr)71 ThreadPlanBase::DoPlanExplainsStop (Event *event_ptr)
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 Vote
ShouldReportStop(Event * event_ptr)82 ThreadPlanBase::ShouldReportStop(Event *event_ptr)
83 {
84 StopInfoSP stop_info_sp = m_thread.GetStopInfo ();
85 if (stop_info_sp)
86 {
87 bool should_notify = stop_info_sp->ShouldNotify(event_ptr);
88 if (should_notify)
89 return eVoteYes;
90 else
91 return eVoteNoOpinion;
92 }
93 else
94 return eVoteNoOpinion;
95 }
96
97 bool
ShouldStop(Event * event_ptr)98 ThreadPlanBase::ShouldStop (Event *event_ptr)
99 {
100 m_stop_vote = eVoteYes;
101 m_run_vote = eVoteYes;
102
103 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
104
105 StopInfoSP stop_info_sp = GetPrivateStopInfo ();
106 if (stop_info_sp)
107 {
108 StopReason reason = stop_info_sp->GetStopReason ();
109 switch (reason)
110 {
111 case eStopReasonInvalid:
112 case eStopReasonNone:
113 // This
114 m_run_vote = eVoteNoOpinion;
115 m_stop_vote = eVoteNo;
116 return false;
117
118 case eStopReasonBreakpoint:
119 case eStopReasonWatchpoint:
120 if (stop_info_sp->ShouldStopSynchronous(event_ptr))
121 {
122 // If we are going to stop for a breakpoint, then unship the other plans
123 // at this point. Don't force the discard, however, so Master plans can stay
124 // in place if they want to.
125 if (log)
126 log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (breakpoint hit.)", m_thread.GetID());
127 m_thread.DiscardThreadPlans(false);
128 return true;
129 }
130 // If we aren't going to stop at this breakpoint, and it is internal,
131 // don't report this stop or the subsequent running event.
132 // Otherwise we will post the stopped & running, but the stopped event will get marked
133 // with "restarted" so the UI will know to wait and expect the consequent "running".
134 if (stop_info_sp->ShouldNotify (event_ptr))
135 {
136 m_stop_vote = eVoteYes;
137 m_run_vote = eVoteYes;
138 }
139 else
140 {
141 m_stop_vote = eVoteNo;
142 m_run_vote = eVoteNo;
143 }
144 return false;
145
146 // TODO: the break below was missing, was this intentional??? If so
147 // please mention it
148 break;
149
150 case eStopReasonException:
151 // If we crashed, discard thread plans and stop. Don't force the discard, however,
152 // since on rerun the target may clean up this exception and continue normally from there.
153 if (log)
154 log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (exception.)", m_thread.GetID());
155 m_thread.DiscardThreadPlans(false);
156 return true;
157
158 case eStopReasonExec:
159 // If we crashed, discard thread plans and stop. Don't force the discard, however,
160 // since on rerun the target may clean up this exception and continue normally from there.
161 if (log)
162 log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (exec.)", m_thread.GetID());
163 m_thread.DiscardThreadPlans(false);
164 return true;
165
166 case eStopReasonThreadExiting:
167 case eStopReasonSignal:
168 if (stop_info_sp->ShouldStop(event_ptr))
169 {
170 if (log)
171 log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (signal.)", m_thread.GetID());
172 m_thread.DiscardThreadPlans(false);
173 return true;
174 }
175 else
176 {
177 // We're not going to stop, but while we are here, let's figure out
178 // whether to report this.
179 if (stop_info_sp->ShouldNotify(event_ptr))
180 m_stop_vote = eVoteYes;
181 else
182 m_stop_vote = eVoteNo;
183 }
184 return false;
185
186 default:
187 return true;
188 }
189
190 }
191 else
192 {
193 m_run_vote = eVoteNoOpinion;
194 m_stop_vote = eVoteNo;
195 }
196
197 // If there's no explicit reason to stop, then we will continue.
198 return false;
199 }
200
201 bool
StopOthers()202 ThreadPlanBase::StopOthers ()
203 {
204 return false;
205 }
206
207 StateType
GetPlanRunState()208 ThreadPlanBase::GetPlanRunState ()
209 {
210 return eStateRunning;
211 }
212
213 bool
WillStop()214 ThreadPlanBase::WillStop ()
215 {
216 return true;
217 }
218
219 bool
DoWillResume(lldb::StateType resume_state,bool current_plan)220 ThreadPlanBase::DoWillResume (lldb::StateType resume_state, bool current_plan)
221 {
222 // Reset these to the default values so we don't set them wrong, then not get asked
223 // for a while, then return the wrong answer.
224 m_run_vote = eVoteNoOpinion;
225 m_stop_vote = eVoteNo;
226 return true;
227 }
228
229
230 // The base plan is never done.
231 bool
MischiefManaged()232 ThreadPlanBase::MischiefManaged ()
233 {
234 // The base plan is never done.
235 return false;
236 }
237
238