ThreadPlanStepUntil.cpp revision 314564 
1//===-- ThreadPlanStepUntil.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// C Includes
11// C++ Includes
12// Other libraries and framework includes
13// Project includes
14#include "lldb/Target/ThreadPlanStepUntil.h"
15#include "lldb/Breakpoint/Breakpoint.h"
16#include "lldb/Core/Log.h"
17#include "lldb/Target/Process.h"
18#include "lldb/Target/RegisterContext.h"
19#include "lldb/Target/StopInfo.h"
20#include "lldb/Target/Target.h"
21
22using namespace lldb;
23using namespace lldb_private;
24
25//----------------------------------------------------------------------
26// ThreadPlanStepUntil: Run until we reach a given line number or step out of
27// the current frame
28//----------------------------------------------------------------------
29
30ThreadPlanStepUntil::ThreadPlanStepUntil(Thread &thread,
31                                         lldb::addr_t *address_list,
32                                         size_t num_addresses, bool stop_others,
33                                         uint32_t frame_idx)
34    : ThreadPlan(ThreadPlan::eKindStepUntil, "Step until", thread,
35                 eVoteNoOpinion, eVoteNoOpinion),
36      m_step_from_insn(LLDB_INVALID_ADDRESS),
37      m_return_bp_id(LLDB_INVALID_BREAK_ID),
38      m_return_addr(LLDB_INVALID_ADDRESS), m_stepped_out(false),
39      m_should_stop(false), m_ran_analyze(false), m_explains_stop(false),
40      m_until_points(), m_stop_others(stop_others) {
41  // Stash away our "until" addresses:
42  TargetSP target_sp(m_thread.CalculateTarget());
43
44  StackFrameSP frame_sp(m_thread.GetStackFrameAtIndex(frame_idx));
45  if (frame_sp) {
46    m_step_from_insn = frame_sp->GetStackID().GetPC();
47    lldb::user_id_t thread_id = m_thread.GetID();
48
49    // Find the return address and set a breakpoint there:
50    // FIXME - can we do this more securely if we know first_insn?
51
52    StackFrameSP return_frame_sp(m_thread.GetStackFrameAtIndex(frame_idx + 1));
53    if (return_frame_sp) {
54      // TODO: add inline functionality
55      m_return_addr = return_frame_sp->GetStackID().GetPC();
56      Breakpoint *return_bp =
57          target_sp->CreateBreakpoint(m_return_addr, true, false).get();
58      if (return_bp != nullptr) {
59        return_bp->SetThreadID(thread_id);
60        m_return_bp_id = return_bp->GetID();
61        return_bp->SetBreakpointKind("until-return-backstop");
62      }
63    }
64
65    m_stack_id = frame_sp->GetStackID();
66
67    // Now set breakpoints on all our return addresses:
68    for (size_t i = 0; i < num_addresses; i++) {
69      Breakpoint *until_bp =
70          target_sp->CreateBreakpoint(address_list[i], true, false).get();
71      if (until_bp != nullptr) {
72        until_bp->SetThreadID(thread_id);
73        m_until_points[address_list[i]] = until_bp->GetID();
74        until_bp->SetBreakpointKind("until-target");
75      } else {
76        m_until_points[address_list[i]] = LLDB_INVALID_BREAK_ID;
77      }
78    }
79  }
80}
81
82ThreadPlanStepUntil::~ThreadPlanStepUntil() { Clear(); }
83
84void ThreadPlanStepUntil::Clear() {
85  TargetSP target_sp(m_thread.CalculateTarget());
86  if (target_sp) {
87    if (m_return_bp_id != LLDB_INVALID_BREAK_ID) {
88      target_sp->RemoveBreakpointByID(m_return_bp_id);
89      m_return_bp_id = LLDB_INVALID_BREAK_ID;
90    }
91
92    until_collection::iterator pos, end = m_until_points.end();
93    for (pos = m_until_points.begin(); pos != end; pos++) {
94      target_sp->RemoveBreakpointByID((*pos).second);
95    }
96  }
97  m_until_points.clear();
98}
99
100void ThreadPlanStepUntil::GetDescription(Stream *s,
101                                         lldb::DescriptionLevel level) {
102  if (level == lldb::eDescriptionLevelBrief) {
103    s->Printf("step until");
104    if (m_stepped_out)
105      s->Printf(" - stepped out");
106  } else {
107    if (m_until_points.size() == 1)
108      s->Printf("Stepping from address 0x%" PRIx64 " until we reach 0x%" PRIx64
109                " using breakpoint %d",
110                (uint64_t)m_step_from_insn,
111                (uint64_t)(*m_until_points.begin()).first,
112                (*m_until_points.begin()).second);
113    else {
114      until_collection::iterator pos, end = m_until_points.end();
115      s->Printf("Stepping from address 0x%" PRIx64 " until we reach one of:",
116                (uint64_t)m_step_from_insn);
117      for (pos = m_until_points.begin(); pos != end; pos++) {
118        s->Printf("\n\t0x%" PRIx64 " (bp: %d)", (uint64_t)(*pos).first,
119                  (*pos).second);
120      }
121    }
122    s->Printf(" stepped out address is 0x%" PRIx64 ".",
123              (uint64_t)m_return_addr);
124  }
125}
126
127bool ThreadPlanStepUntil::ValidatePlan(Stream *error) {
128  if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
129    return false;
130  else {
131    until_collection::iterator pos, end = m_until_points.end();
132    for (pos = m_until_points.begin(); pos != end; pos++) {
133      if (!LLDB_BREAK_ID_IS_VALID((*pos).second))
134        return false;
135    }
136    return true;
137  }
138}
139
140void ThreadPlanStepUntil::AnalyzeStop() {
141  if (m_ran_analyze)
142    return;
143
144  StopInfoSP stop_info_sp = GetPrivateStopInfo();
145  m_should_stop = true;
146  m_explains_stop = false;
147
148  if (stop_info_sp) {
149    StopReason reason = stop_info_sp->GetStopReason();
150
151    if (reason == eStopReasonBreakpoint) {
152      // If this is OUR breakpoint, we're fine, otherwise we don't know why this
153      // happened...
154      BreakpointSiteSP this_site =
155          m_thread.GetProcess()->GetBreakpointSiteList().FindByID(
156              stop_info_sp->GetValue());
157      if (!this_site) {
158        m_explains_stop = false;
159        return;
160      }
161
162      if (this_site->IsBreakpointAtThisSite(m_return_bp_id)) {
163        // If we are at our "step out" breakpoint, and the stack depth has
164        // shrunk, then
165        // this is indeed our stop.
166        // If the stack depth has grown, then we've hit our step out breakpoint
167        // recursively.
168        // If we are the only breakpoint at that location, then we do explain
169        // the stop, and
170        // we'll just continue.
171        // If there was another breakpoint here, then we don't explain the stop,
172        // but we won't
173        // mark ourselves Completed, because maybe that breakpoint will
174        // continue, and then
175        // we'll finish the "until".
176        bool done;
177        StackID cur_frame_zero_id;
178
179        done = (m_stack_id < cur_frame_zero_id);
180
181        if (done) {
182          m_stepped_out = true;
183          SetPlanComplete();
184        } else
185          m_should_stop = false;
186
187        if (this_site->GetNumberOfOwners() == 1)
188          m_explains_stop = true;
189        else
190          m_explains_stop = false;
191        return;
192      } else {
193        // Check if we've hit one of our "until" breakpoints.
194        until_collection::iterator pos, end = m_until_points.end();
195        for (pos = m_until_points.begin(); pos != end; pos++) {
196          if (this_site->IsBreakpointAtThisSite((*pos).second)) {
197            // If we're at the right stack depth, then we're done.
198
199            bool done;
200            StackID frame_zero_id =
201                m_thread.GetStackFrameAtIndex(0)->GetStackID();
202
203            if (frame_zero_id == m_stack_id)
204              done = true;
205            else if (frame_zero_id < m_stack_id)
206              done = false;
207            else {
208              StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(1);
209
210              // But if we can't even unwind one frame we should just get out of
211              // here & stop...
212              if (older_frame_sp) {
213                const SymbolContext &older_context =
214                    older_frame_sp->GetSymbolContext(eSymbolContextEverything);
215                SymbolContext stack_context;
216                m_stack_id.GetSymbolContextScope()->CalculateSymbolContext(
217                    &stack_context);
218
219                done = (older_context == stack_context);
220              } else
221                done = false;
222            }
223
224            if (done)
225              SetPlanComplete();
226            else
227              m_should_stop = false;
228
229            // Otherwise we've hit this breakpoint recursively.  If we're the
230            // only breakpoint here, then we do explain the stop, and we'll
231            // continue.
232            // If not then we should let higher plans handle this stop.
233            if (this_site->GetNumberOfOwners() == 1)
234              m_explains_stop = true;
235            else {
236              m_should_stop = true;
237              m_explains_stop = false;
238            }
239            return;
240          }
241        }
242      }
243      // If we get here we haven't hit any of our breakpoints, so let the higher
244      // plans take care of the stop.
245      m_explains_stop = false;
246      return;
247    } else if (IsUsuallyUnexplainedStopReason(reason)) {
248      m_explains_stop = false;
249    } else {
250      m_explains_stop = true;
251    }
252  }
253}
254
255bool ThreadPlanStepUntil::DoPlanExplainsStop(Event *event_ptr) {
256  // We don't explain signals or breakpoints (breakpoints that handle stepping
257  // in or
258  // out will be handled by a child plan.
259  AnalyzeStop();
260  return m_explains_stop;
261}
262
263bool ThreadPlanStepUntil::ShouldStop(Event *event_ptr) {
264  // If we've told our self in ExplainsStop that we plan to continue, then
265  // do so here.  Otherwise, as long as this thread has stopped for a reason,
266  // we will stop.
267
268  StopInfoSP stop_info_sp = GetPrivateStopInfo();
269  if (!stop_info_sp || stop_info_sp->GetStopReason() == eStopReasonNone)
270    return false;
271
272  AnalyzeStop();
273  return m_should_stop;
274}
275
276bool ThreadPlanStepUntil::StopOthers() { return m_stop_others; }
277
278StateType ThreadPlanStepUntil::GetPlanRunState() { return eStateRunning; }
279
280bool ThreadPlanStepUntil::DoWillResume(StateType resume_state,
281                                       bool current_plan) {
282  if (current_plan) {
283    TargetSP target_sp(m_thread.CalculateTarget());
284    if (target_sp) {
285      Breakpoint *return_bp =
286          target_sp->GetBreakpointByID(m_return_bp_id).get();
287      if (return_bp != nullptr)
288        return_bp->SetEnabled(true);
289
290      until_collection::iterator pos, end = m_until_points.end();
291      for (pos = m_until_points.begin(); pos != end; pos++) {
292        Breakpoint *until_bp =
293            target_sp->GetBreakpointByID((*pos).second).get();
294        if (until_bp != nullptr)
295          until_bp->SetEnabled(true);
296      }
297    }
298  }
299
300  m_should_stop = true;
301  m_ran_analyze = false;
302  m_explains_stop = false;
303  return true;
304}
305
306bool ThreadPlanStepUntil::WillStop() {
307  TargetSP target_sp(m_thread.CalculateTarget());
308  if (target_sp) {
309    Breakpoint *return_bp = target_sp->GetBreakpointByID(m_return_bp_id).get();
310    if (return_bp != nullptr)
311      return_bp->SetEnabled(false);
312
313    until_collection::iterator pos, end = m_until_points.end();
314    for (pos = m_until_points.begin(); pos != end; pos++) {
315      Breakpoint *until_bp = target_sp->GetBreakpointByID((*pos).second).get();
316      if (until_bp != nullptr)
317        until_bp->SetEnabled(false);
318    }
319  }
320  return true;
321}
322
323bool ThreadPlanStepUntil::MischiefManaged() {
324  // I'm letting "PlanExplainsStop" do all the work, and just reporting that
325  // here.
326  bool done = false;
327  if (IsPlanComplete()) {
328    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
329    if (log)
330      log->Printf("Completed step until plan.");
331
332    Clear();
333    done = true;
334  }
335  if (done)
336    ThreadPlan::MischiefManaged();
337
338  return done;
339}
340