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
27using namespace lldb;
28using 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
36ThreadPlanBase::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
53ThreadPlanBase::~ThreadPlanBase ()
54{
55
56}
57
58void
59ThreadPlanBase::GetDescription (Stream *s, lldb::DescriptionLevel level)
60{
61    s->Printf ("Base thread plan.");
62}
63
64bool
65ThreadPlanBase::ValidatePlan (Stream *error)
66{
67    return true;
68}
69
70bool
71ThreadPlanBase::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
81Vote
82ThreadPlanBase::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
97bool
98ThreadPlanBase::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
201bool
202ThreadPlanBase::StopOthers ()
203{
204    return false;
205}
206
207StateType
208ThreadPlanBase::GetPlanRunState ()
209{
210    return eStateRunning;
211}
212
213bool
214ThreadPlanBase::WillStop ()
215{
216    return true;
217}
218
219bool
220ThreadPlanBase::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.
231bool
232ThreadPlanBase::MischiefManaged ()
233{
234    // The base plan is never done.
235    return false;
236}
237
238