1//===-- ThreadPlanStepOverBreakpoint.cpp ------------------------*- C++ -*-===//
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/ThreadPlanStepOverBreakpoint.h"
10
11#include "lldb/Target/Process.h"
12#include "lldb/Target/RegisterContext.h"
13#include "lldb/Utility/Log.h"
14#include "lldb/Utility/Stream.h"
15
16using namespace lldb;
17using namespace lldb_private;
18
19// ThreadPlanStepOverBreakpoint: Single steps over a breakpoint bp_site_sp at
20// the pc.
21
22ThreadPlanStepOverBreakpoint::ThreadPlanStepOverBreakpoint(Thread &thread)
23    : ThreadPlan(
24          ThreadPlan::eKindStepOverBreakpoint, "Step over breakpoint trap",
25          thread, eVoteNo,
26          eVoteNoOpinion), // We need to report the run since this happens
27                           // first in the thread plan stack when stepping over
28                           // a breakpoint
29      m_breakpoint_addr(LLDB_INVALID_ADDRESS),
30      m_auto_continue(false), m_reenabled_breakpoint_site(false)
31
32{
33  m_breakpoint_addr = m_thread.GetRegisterContext()->GetPC();
34  m_breakpoint_site_id =
35      m_thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress(
36          m_breakpoint_addr);
37}
38
39ThreadPlanStepOverBreakpoint::~ThreadPlanStepOverBreakpoint() {}
40
41void ThreadPlanStepOverBreakpoint::GetDescription(
42    Stream *s, lldb::DescriptionLevel level) {
43  s->Printf("Single stepping past breakpoint site %" PRIu64 " at 0x%" PRIx64,
44            m_breakpoint_site_id, (uint64_t)m_breakpoint_addr);
45}
46
47bool ThreadPlanStepOverBreakpoint::ValidatePlan(Stream *error) { return true; }
48
49bool ThreadPlanStepOverBreakpoint::DoPlanExplainsStop(Event *event_ptr) {
50  StopInfoSP stop_info_sp = GetPrivateStopInfo();
51  if (stop_info_sp) {
52    // It's a little surprising that we stop here for a breakpoint hit.
53    // However, when you single step ONTO a breakpoint we still want to call
54    // that a breakpoint hit, and trigger the actions, etc.  Otherwise you
55    // would see the
56    // PC at the breakpoint without having triggered the actions, then you'd
57    // continue, the PC wouldn't change,
58    // and you'd see the breakpoint hit, which would be odd. So the lower
59    // levels fake "step onto breakpoint address" and return that as a
60    // breakpoint.  So our trace step COULD appear as a breakpoint hit if the
61    // next instruction also contained a breakpoint.
62    StopReason reason = stop_info_sp->GetStopReason();
63
64    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
65    LLDB_LOGF(log, "Step over breakpoint stopped for reason: %s.",
66              Thread::StopReasonAsCString(reason));
67
68    switch (reason) {
69      case eStopReasonTrace:
70      case eStopReasonNone:
71        return true;
72      case eStopReasonBreakpoint:
73      {
74        // It's a little surprising that we stop here for a breakpoint hit.
75        // However, when you single step ONTO a breakpoint we still want to call
76        // that a breakpoint hit, and trigger the actions, etc.  Otherwise you
77        // would see the PC at the breakpoint without having triggered the
78        // actions, then you'd continue, the PC wouldn't change, and you'd see
79        // the breakpoint hit, which would be odd. So the lower levels fake
80        // "step onto breakpoint address" and return that as a breakpoint hit.
81        // So our trace step COULD appear as a breakpoint hit if the next
82        // instruction also contained a breakpoint.  We don't want to handle
83        // that, since we really don't know what to do with breakpoint hits.
84        // But make sure we don't set ourselves to auto-continue or we'll wrench
85        // control away from the plans that can deal with this.
86        // Be careful, however, as we may have "seen a breakpoint under the PC
87        // because we stopped without changing the PC, in which case we do want
88        // to re-claim this stop so we'll try again.
89        lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
90
91        if (pc_addr == m_breakpoint_addr) {
92          LLDB_LOGF(log,
93                    "Got breakpoint stop reason but pc: 0x%" PRIx64
94                    "hasn't changed.",
95                    pc_addr);
96          return true;
97        }
98
99        SetAutoContinue(false);
100        return false;
101      }
102      default:
103        return false;
104    }
105  }
106  return false;
107}
108
109bool ThreadPlanStepOverBreakpoint::ShouldStop(Event *event_ptr) {
110  return !ShouldAutoContinue(event_ptr);
111}
112
113bool ThreadPlanStepOverBreakpoint::StopOthers() { return true; }
114
115StateType ThreadPlanStepOverBreakpoint::GetPlanRunState() {
116  return eStateStepping;
117}
118
119bool ThreadPlanStepOverBreakpoint::DoWillResume(StateType resume_state,
120                                                bool current_plan) {
121  if (current_plan) {
122    BreakpointSiteSP bp_site_sp(
123        m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress(
124            m_breakpoint_addr));
125    if (bp_site_sp && bp_site_sp->IsEnabled()) {
126      m_thread.GetProcess()->DisableBreakpointSite(bp_site_sp.get());
127      m_reenabled_breakpoint_site = false;
128    }
129  }
130  return true;
131}
132
133bool ThreadPlanStepOverBreakpoint::WillStop() {
134  ReenableBreakpointSite();
135  return true;
136}
137
138void ThreadPlanStepOverBreakpoint::WillPop() {
139  ReenableBreakpointSite();
140}
141
142bool ThreadPlanStepOverBreakpoint::MischiefManaged() {
143  lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
144
145  if (pc_addr == m_breakpoint_addr) {
146    // If we are still at the PC of our breakpoint, then for some reason we
147    // didn't get a chance to run.
148    return false;
149  } else {
150    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
151    LLDB_LOGF(log, "Completed step over breakpoint plan.");
152    // Otherwise, re-enable the breakpoint we were stepping over, and we're
153    // done.
154    ReenableBreakpointSite();
155    ThreadPlan::MischiefManaged();
156    return true;
157  }
158}
159
160void ThreadPlanStepOverBreakpoint::ReenableBreakpointSite() {
161  if (!m_reenabled_breakpoint_site) {
162    m_reenabled_breakpoint_site = true;
163    BreakpointSiteSP bp_site_sp(
164        m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress(
165            m_breakpoint_addr));
166    if (bp_site_sp) {
167      m_thread.GetProcess()->EnableBreakpointSite(bp_site_sp.get());
168    }
169  }
170}
171void ThreadPlanStepOverBreakpoint::ThreadDestroyed() {
172  ReenableBreakpointSite();
173}
174
175void ThreadPlanStepOverBreakpoint::SetAutoContinue(bool do_it) {
176  m_auto_continue = do_it;
177}
178
179bool ThreadPlanStepOverBreakpoint::ShouldAutoContinue(Event *event_ptr) {
180  return m_auto_continue;
181}
182
183bool ThreadPlanStepOverBreakpoint::IsPlanStale() {
184  return m_thread.GetRegisterContext()->GetPC() != m_breakpoint_addr;
185}
186