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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
//===-- ThreadPlanStepOut.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/ThreadPlanStepOut.h"
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/lldb-private-log.h"
#include "lldb/Core/Log.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h"
using namespace lldb;
using namespace lldb_private;
//----------------------------------------------------------------------
// ThreadPlanStepOut: Step out of the current frame
//----------------------------------------------------------------------
ThreadPlanStepOut::ThreadPlanStepOut
(
Thread &thread,
SymbolContext *context,
bool first_insn,
bool stop_others,
Vote stop_vote,
Vote run_vote
) :
ThreadPlan (ThreadPlan::eKindStepOut, "Step out", thread, stop_vote, run_vote),
m_step_from_context (context),
m_step_from_insn (LLDB_INVALID_ADDRESS),
m_return_bp_id (LLDB_INVALID_BREAK_ID),
m_return_addr (LLDB_INVALID_ADDRESS),
m_first_insn (first_insn),
m_stop_others (stop_others)
{
m_step_from_insn = m_thread.GetRegisterContext()->GetPC(0);
// Find the return address and set a breakpoint there:
// FIXME - can we do this more securely if we know first_insn?
StackFrame *return_frame = m_thread.GetStackFrameAtIndex(1).get();
if (return_frame)
{
// TODO: check for inlined frames and do the right thing...
m_return_addr = return_frame->GetRegisterContext()->GetPC();
Breakpoint *return_bp = m_thread.GetProcess().GetTarget().CreateBreakpoint (m_return_addr, true).get();
if (return_bp != NULL)
{
return_bp->SetThreadID(m_thread.GetID());
m_return_bp_id = return_bp->GetID();
}
else
{
m_return_bp_id = LLDB_INVALID_BREAK_ID;
}
}
m_stack_depth = m_thread.GetStackFrameCount();
}
ThreadPlanStepOut::~ThreadPlanStepOut ()
{
if (m_return_bp_id != LLDB_INVALID_BREAK_ID)
m_thread.GetProcess().GetTarget().RemoveBreakpointByID(m_return_bp_id);
}
void
ThreadPlanStepOut::GetDescription (Stream *s, lldb::DescriptionLevel level)
{
if (level == lldb::eDescriptionLevelBrief)
s->Printf ("step out");
else
{
s->Printf ("Stepping out from address 0x%llx to return address 0x%llx using breakpoint site %d",
(uint64_t)m_step_from_insn,
(uint64_t)m_return_addr,
m_return_bp_id);
}
}
bool
ThreadPlanStepOut::ValidatePlan (Stream *error)
{
if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
return false;
else
return true;
}
bool
ThreadPlanStepOut::PlanExplainsStop ()
{
// We don't explain signals or breakpoints (breakpoints that handle stepping in or
// out will be handled by a child plan.
StopInfoSP stop_info_sp = GetPrivateStopReason();
if (stop_info_sp)
{
StopReason reason = stop_info_sp->GetStopReason();
switch (reason)
{
case eStopReasonBreakpoint:
{
// If this is OUR breakpoint, we're fine, otherwise we don't know why this happened...
BreakpointSiteSP site_sp (m_thread.GetProcess().GetBreakpointSiteList().FindByID (stop_info_sp->GetValue()));
if (site_sp && site_sp->IsBreakpointAtThisSite (m_return_bp_id))
{
// If there was only one owner, then we're done. But if we also hit some
// user breakpoint on our way out, we should mark ourselves as done, but
// also not claim to explain the stop, since it is more important to report
// the user breakpoint than the step out completion.
if (site_sp->GetNumberOfOwners() == 1)
return true;
SetPlanComplete();
}
return false;
}
case eStopReasonWatchpoint:
case eStopReasonSignal:
case eStopReasonException:
return false;
default:
return true;
}
}
return true;
}
bool
ThreadPlanStepOut::ShouldStop (Event *event_ptr)
{
if (IsPlanComplete()
|| m_thread.GetRegisterContext()->GetPC() == m_return_addr
|| m_stack_depth > m_thread.GetStackFrameCount())
{
SetPlanComplete();
return true;
}
else
return false;
}
bool
ThreadPlanStepOut::StopOthers ()
{
return m_stop_others;
}
StateType
ThreadPlanStepOut::RunState ()
{
return eStateRunning;
}
bool
ThreadPlanStepOut::WillResume (StateType resume_state, bool current_plan)
{
ThreadPlan::WillResume (resume_state, current_plan);
if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
return false;
if (current_plan)
{
Breakpoint *return_bp = m_thread.GetProcess().GetTarget().GetBreakpointByID(m_return_bp_id).get();
if (return_bp != NULL)
return_bp->SetEnabled (true);
}
return true;
}
bool
ThreadPlanStepOut::WillStop ()
{
Breakpoint *return_bp = m_thread.GetProcess().GetTarget().GetBreakpointByID(m_return_bp_id).get();
if (return_bp != NULL)
return_bp->SetEnabled (false);
return true;
}
bool
ThreadPlanStepOut::MischiefManaged ()
{
if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
{
// If I couldn't set this breakpoint, then I'm just going to jettison myself.
return true;
}
else if (IsPlanComplete())
{
// Did I reach my breakpoint? If so I'm done.
//
// I also check the stack depth, since if we've blown past the breakpoint for some
// reason and we're now stopping for some other reason altogether, then we're done
// with this step out operation.
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
if (log)
log->Printf("Completed step out plan.");
m_thread.GetProcess().GetTarget().RemoveBreakpointByID (m_return_bp_id);
m_return_bp_id = LLDB_INVALID_BREAK_ID;
ThreadPlan::MischiefManaged ();
return true;
}
else
{
return false;
}
}
|
