LLDB mainline
ThreadPlanStepOverBreakpoint.cpp
Go to the documentation of this file.
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
10
11#include "lldb/Target/Process.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
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();
36 thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress(
38}
39
41
44 s->Printf("Single stepping past breakpoint site %" PRIu64 " at 0x%" PRIx64,
46}
47
49
51 StopInfoSP stop_info_sp = GetPrivateStopInfo();
52 if (stop_info_sp) {
53 StopReason reason = stop_info_sp->GetStopReason();
54
55 Log *log = GetLog(LLDBLog::Step);
56 LLDB_LOG(log, "Step over breakpoint stopped for reason: {0}.",
58
59 switch (reason) {
61 case eStopReasonNone:
62 return true;
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
101 return !ShouldAutoContinue(event_ptr);
102}
103
105
106// This thread plan does a single instruction step over a breakpoint instruction
107// and needs to not resume other threads, so return false to stop the
108// ThreadPlanSingleThreadTimeout from timing out and trying to resume all
109// threads. If all threads gets resumed before we disable, single step and
110// re-enable the breakpoint, we can miss breakpoints on other threads.
112
114 return eStateStepping;
115}
116
118 bool current_plan) {
119 if (current_plan) {
120 BreakpointSiteSP bp_site_sp(
122 if (bp_site_sp && bp_site_sp->IsEnabled()) {
123 m_process.DisableBreakpointSite(bp_site_sp.get());
125 }
126 }
127 return true;
128}
129
132 return true;
133}
134
136
138 lldb::addr_t pc_addr = GetThread().GetRegisterContext()->GetPC();
139
140 if (pc_addr == m_breakpoint_addr) {
141 // If we are still at the PC of our breakpoint, then for some reason we
142 // didn't get a chance to run.
143 return false;
144 } else {
145 Log *log = GetLog(LLDBLog::Step);
146 LLDB_LOGF(log, "Completed step over breakpoint plan.");
147 // Otherwise, re-enable the breakpoint we were stepping over, and we're
148 // done.
151 return true;
152 }
153}
154
158 BreakpointSiteSP bp_site_sp(
160 if (bp_site_sp) {
161 m_process.EnableBreakpointSite(bp_site_sp.get());
162 }
163 }
164}
167}
168
170 m_auto_continue = do_it;
171}
172
174 return m_auto_continue;
175}
176
178 return GetThread().GetRegisterContext()->GetPC() != m_breakpoint_addr;
179}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:369
#define LLDB_LOGF(log,...)
Definition: Log.h:376
virtual Status EnableBreakpointSite(BreakpointSite *bp_site)
Definition: Process.h:2117
StopPointSiteList< lldb_private::BreakpointSite > & GetBreakpointSiteList()
Definition: Process.cpp:1583
virtual Status DisableBreakpointSite(BreakpointSite *bp_site)
Definition: Process.h:2122
StopPointSiteSP FindByAddress(lldb::addr_t addr)
Returns a shared pointer to the site at address addr.
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
bool ValidatePlan(Stream *error) override
Returns whether this plan could be successfully created.
bool DoWillResume(lldb::StateType resume_state, bool current_plan) override
void GetDescription(Stream *s, lldb::DescriptionLevel level) override
Print a description of this thread to the stream s.
bool ShouldAutoContinue(Event *event_ptr) override
Returns whether this thread plan overrides the ShouldStop of subsequently processed plans.
Thread & GetThread()
Returns the Thread that is using this thread plan.
Definition: ThreadPlan.cpp:42
virtual bool MischiefManaged()
Definition: ThreadPlan.cpp:72
lldb::StopInfoSP GetPrivateStopInfo()
Definition: ThreadPlan.h:531
virtual lldb::RegisterContextSP GetRegisterContext()=0
static std::string StopReasonAsString(lldb::StopReason reason)
Definition: Thread.cpp:1709
lldb::ProcessSP GetProcess() const
Definition: Thread.h:157
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:332
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::BreakpointSite > BreakpointSiteSP
Definition: lldb-forward.h:323
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
StateType
Process and Thread States.
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
Definition: lldb-forward.h:431
uint64_t addr_t
Definition: lldb-types.h:80
StopReason
Thread stop reasons.
@ eStopReasonTrace
@ eStopReasonBreakpoint