Mercurial > hg > CbC > CbC_llvm

comparison lldb/source/Target/ThreadPlanBase.cpp @ 150:1d019706d866

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM10
author anatofuz
date Thu, 13 Feb 2020 15:10:13 +0900
parents
children 0572611fdcc8
comparison
equal deleted inserted replaced
147:c2174574ed3a 150:1d019706d866
1 //===-- ThreadPlanBase.cpp ------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "lldb/Target/ThreadPlanBase.h"
10
11 //
12 #include "lldb/Breakpoint/Breakpoint.h"
13 #include "lldb/Breakpoint/BreakpointLocation.h"
14 #include "lldb/Breakpoint/BreakpointSite.h"
15 #include "lldb/Breakpoint/StoppointCallbackContext.h"
16 #include "lldb/Target/Process.h"
17 #include "lldb/Target/RegisterContext.h"
18 #include "lldb/Target/StopInfo.h"
19 #include "lldb/Utility/Log.h"
20 #include "lldb/Utility/Stream.h"
21
22 using namespace lldb;
23 using namespace lldb_private;
24
25 // ThreadPlanBase: This one always stops, and never has anything particular to
26 // do.
27 // FIXME: The "signal handling" policies should probably go here.
28
29 ThreadPlanBase::ThreadPlanBase(Thread &thread)
30 : ThreadPlan(ThreadPlan::eKindBase, "base plan", thread, eVoteYes,
31 eVoteNoOpinion) {
32 // Set the tracer to a default tracer.
33 // FIXME: need to add a thread settings variable to pix various tracers...
34 #define THREAD_PLAN_USE_ASSEMBLY_TRACER 1
35
36 #ifdef THREAD_PLAN_USE_ASSEMBLY_TRACER
37 ThreadPlanTracerSP new_tracer_sp(new ThreadPlanAssemblyTracer(m_thread));
38 #else
39 ThreadPlanTracerSP new_tracer_sp(new ThreadPlanTracer(m_thread));
40 #endif
41 new_tracer_sp->EnableTracing(m_thread.GetTraceEnabledState());
42 SetThreadPlanTracer(new_tracer_sp);
43 SetIsMasterPlan(true);
44 }
45
46 ThreadPlanBase::~ThreadPlanBase() {}
47
48 void ThreadPlanBase::GetDescription(Stream *s, lldb::DescriptionLevel level) {
49 s->Printf("Base thread plan.");
50 }
51
52 bool ThreadPlanBase::ValidatePlan(Stream *error) { return true; }
53
54 bool ThreadPlanBase::DoPlanExplainsStop(Event *event_ptr) {
55 // The base plan should defer to its tracer, since by default it always
56 // handles the stop.
57 return !TracerExplainsStop();
58 }
59
60 Vote ThreadPlanBase::ShouldReportStop(Event *event_ptr) {
61 StopInfoSP stop_info_sp = m_thread.GetStopInfo();
62 if (stop_info_sp) {
63 bool should_notify = stop_info_sp->ShouldNotify(event_ptr);
64 if (should_notify)
65 return eVoteYes;
66 else
67 return eVoteNoOpinion;
68 } else
69 return eVoteNoOpinion;
70 }
71
72 bool ThreadPlanBase::ShouldStop(Event *event_ptr) {
73 m_stop_vote = eVoteYes;
74 m_run_vote = eVoteYes;
75
76 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
77
78 StopInfoSP stop_info_sp = GetPrivateStopInfo();
79 if (stop_info_sp) {
80 StopReason reason = stop_info_sp->GetStopReason();
81 switch (reason) {
82 case eStopReasonInvalid:
83 case eStopReasonNone:
84 // This
85 m_run_vote = eVoteNoOpinion;
86 m_stop_vote = eVoteNo;
87 return false;
88
89 case eStopReasonBreakpoint:
90 case eStopReasonWatchpoint:
91 if (stop_info_sp->ShouldStopSynchronous(event_ptr)) {
92 // If we are going to stop for a breakpoint, then unship the other
93 // plans at this point. Don't force the discard, however, so Master
94 // plans can stay in place if they want to.
95 LLDB_LOGF(
96 log,
97 "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
98 " (breakpoint hit.)",
99 m_thread.GetID());
100 m_thread.DiscardThreadPlans(false);
101 return true;
102 }
103 // If we aren't going to stop at this breakpoint, and it is internal,
104 // don't report this stop or the subsequent running event. Otherwise we
105 // will post the stopped & running, but the stopped event will get marked
106 // with "restarted" so the UI will know to wait and expect the consequent
107 // "running".
108 if (stop_info_sp->ShouldNotify(event_ptr)) {
109 m_stop_vote = eVoteYes;
110 m_run_vote = eVoteYes;
111 } else {
112 m_stop_vote = eVoteNo;
113 m_run_vote = eVoteNo;
114 }
115 return false;
116
117 // TODO: the break below was missing, was this intentional??? If so
118 // please mention it
119 break;
120
121 case eStopReasonException:
122 // If we crashed, discard thread plans and stop. Don't force the
123 // discard, however, since on rerun the target may clean up this
124 // exception and continue normally from there.
125 LLDB_LOGF(
126 log,
127 "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
128 " (exception: %s)",
129 m_thread.GetID(), stop_info_sp->GetDescription());
130 m_thread.DiscardThreadPlans(false);
131 return true;
132
133 case eStopReasonExec:
134 // If we crashed, discard thread plans and stop. Don't force the
135 // discard, however, since on rerun the target may clean up this
136 // exception and continue normally from there.
137 LLDB_LOGF(
138 log,
139 "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
140 " (exec.)",
141 m_thread.GetID());
142 m_thread.DiscardThreadPlans(false);
143 return true;
144
145 case eStopReasonThreadExiting:
146 case eStopReasonSignal:
147 if (stop_info_sp->ShouldStop(event_ptr)) {
148 LLDB_LOGF(
149 log,
150 "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
151 " (signal: %s)",
152 m_thread.GetID(), stop_info_sp->GetDescription());
153 m_thread.DiscardThreadPlans(false);
154 return true;
155 } else {
156 // We're not going to stop, but while we are here, let's figure out
157 // whether to report this.
158 if (stop_info_sp->ShouldNotify(event_ptr))
159 m_stop_vote = eVoteYes;
160 else
161 m_stop_vote = eVoteNo;
162 }
163 return false;
164
165 default:
166 return true;
167 }
168
169 } else {
170 m_run_vote = eVoteNoOpinion;
171 m_stop_vote = eVoteNo;
172 }
173
174 // If there's no explicit reason to stop, then we will continue.
175 return false;
176 }
177
178 bool ThreadPlanBase::StopOthers() { return false; }
179
180 StateType ThreadPlanBase::GetPlanRunState() { return eStateRunning; }
181
182 bool ThreadPlanBase::WillStop() { return true; }
183
184 bool ThreadPlanBase::DoWillResume(lldb::StateType resume_state,
185 bool current_plan) {
186 // Reset these to the default values so we don't set them wrong, then not get
187 // asked for a while, then return the wrong answer.
188 m_run_vote = eVoteNoOpinion;
189 m_stop_vote = eVoteNo;
190 return true;
191 }
192
193 // The base plan is never done.
194 bool ThreadPlanBase::MischiefManaged() {
195 // The base plan is never done.
196 return false;
197 }