1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
//===-- ThreadPlanBase.cpp --------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Target/ThreadPlanBase.h"
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
//
#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Breakpoint/BreakpointSite.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/ThreadPlanContinue.h"
#include "lldb/Target/ThreadPlanStepOverBreakpoint.h"
using namespace lldb;
using namespace lldb_private;
//----------------------------------------------------------------------
// ThreadPlanBase: This one always stops, and never has anything particular
// to do.
// FIXME: The "signal handling" policies should probably go here.
//----------------------------------------------------------------------
ThreadPlanBase::ThreadPlanBase (Thread &thread) :
ThreadPlan("base plan", thread, eVoteYes, eVoteNoOpinion)
{
}
ThreadPlanBase::~ThreadPlanBase ()
{
}
void
ThreadPlanBase::GetDescription (Stream *s, lldb::DescriptionLevel level)
{
s->Printf ("Base thread plan.");
}
bool
ThreadPlanBase::ValidatePlan (Stream *error)
{
return true;
}
bool
ThreadPlanBase::PlanExplainsStop ()
{
return true;
}
bool
ThreadPlanBase::ShouldStop (Event *event_ptr)
{
m_stop_vote = eVoteYes;
m_run_vote = eVoteYes;
Thread::StopInfo stop_info;
if (m_thread.GetStopInfo(&stop_info))
{
StopReason reason = stop_info.GetStopReason();
switch (reason)
{
case eStopReasonInvalid:
case eStopReasonNone:
{
m_run_vote = eVoteNo;
m_stop_vote = eVoteNo;
return false;
}
case eStopReasonBreakpoint:
{
// The base plan checks for breakpoint hits.
BreakpointSiteSP bp_site_sp;
//RegisterContext *reg_ctx = m_thread.GetRegisterContext();
//lldb::addr_t pc = reg_ctx->GetPC();
bp_site_sp = m_thread.GetProcess().GetBreakpointSiteList().FindByID (stop_info.GetBreakpointSiteID());
if (bp_site_sp && bp_site_sp->IsEnabled())
{
// We want to step over the breakpoint and then continue. So push these two plans.
StoppointCallbackContext hit_context(event_ptr, &m_thread.GetProcess(), &m_thread, m_thread.GetStackFrameAtIndex(0).get());
bool should_stop = m_thread.GetProcess().GetBreakpointSiteList().ShouldStop(&hit_context, bp_site_sp->GetID());
if (!should_stop)
{
// If we aren't going to stop at this breakpoint, and it is internal, don't report this stop or the subsequent
// running event. Otherwise we will post the stopped & running, but the stopped event will get marked
// with "restarted" so the UI will know to wait and expect the consequent "running".
uint32_t i;
bool is_wholly_internal = true;
for (i = 0; i < bp_site_sp->GetNumberOfOwners(); i++)
{
if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal())
{
is_wholly_internal = false;
break;
}
}
if (is_wholly_internal)
{
m_stop_vote = eVoteNo;
m_run_vote = eVoteNo;
}
else
{
m_stop_vote = eVoteYes;
m_run_vote = eVoteYes;
}
}
else
{
// If we are going to stop for a breakpoint, then unship the other plans
// at this point. Don't force the discard, however, so Master plans can stay
// in place if they want to.
m_thread.DiscardThreadPlans(false);
}
return should_stop;
}
}
case eStopReasonException:
// If we crashed, discard thread plans and stop. Don't force the discard, however,
// since on rerun the target may clean up this exception and continue normally from there.
m_thread.DiscardThreadPlans(false);
return true;
case eStopReasonSignal:
{
// Check the signal handling, and if we are stopping for the signal,
// discard the plans and stop.
UnixSignals &signals = m_thread.GetProcess().GetUnixSignals();
uint32_t signo = stop_info.GetSignal();
if (signals.GetShouldStop(signo))
{
m_thread.DiscardThreadPlans(false);
return true;
}
else
{
// We're not going to stop, but while we are here, let's figure out
// whether to report this.
if (signals.GetShouldNotify(signo))
m_stop_vote = eVoteYes;
else
m_stop_vote = eVoteNo;
return false;
}
}
default:
return true;
}
}
// If there's no explicit reason to stop, then we will continue.
return false;
}
bool
ThreadPlanBase::StopOthers ()
{
return false;
}
StateType
ThreadPlanBase::RunState ()
{
return eStateRunning;
}
bool
ThreadPlanBase::WillStop ()
{
return true;
}
// The base plan is never done.
bool
ThreadPlanBase::MischiefManaged ()
{
// The base plan is never done.
return false;
}
|
