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

source code of lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp