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/Log.h" 14 #include "lldb/Utility/Stream.h" 15 16 using namespace lldb; 17 using namespace lldb_private; 18 19 // ThreadPlanStepOverBreakpoint: Single steps over a breakpoint bp_site_sp at 20 // the pc. 21 22 ThreadPlanStepOverBreakpoint::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 = thread.GetRegisterContext()->GetPC(); 34 m_breakpoint_site_id = 35 thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress( 36 m_breakpoint_addr); 37 } 38 39 ThreadPlanStepOverBreakpoint::~ThreadPlanStepOverBreakpoint() {} 40 41 void 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 47 bool ThreadPlanStepOverBreakpoint::ValidatePlan(Stream *error) { return true; } 48 49 bool 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_LOG(log, "Step over breakpoint stopped for reason: {0}.", 66 Thread::StopReasonAsString(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 = GetThread().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 109 bool ThreadPlanStepOverBreakpoint::ShouldStop(Event *event_ptr) { 110 return !ShouldAutoContinue(event_ptr); 111 } 112 113 bool ThreadPlanStepOverBreakpoint::StopOthers() { return true; } 114 115 StateType ThreadPlanStepOverBreakpoint::GetPlanRunState() { 116 return eStateStepping; 117 } 118 119 bool ThreadPlanStepOverBreakpoint::DoWillResume(StateType resume_state, 120 bool current_plan) { 121 if (current_plan) { 122 BreakpointSiteSP bp_site_sp( 123 m_process.GetBreakpointSiteList().FindByAddress(m_breakpoint_addr)); 124 if (bp_site_sp && bp_site_sp->IsEnabled()) { 125 m_process.DisableBreakpointSite(bp_site_sp.get()); 126 m_reenabled_breakpoint_site = false; 127 } 128 } 129 return true; 130 } 131 132 bool ThreadPlanStepOverBreakpoint::WillStop() { 133 ReenableBreakpointSite(); 134 return true; 135 } 136 137 void ThreadPlanStepOverBreakpoint::WillPop() { 138 ReenableBreakpointSite(); 139 } 140 141 bool ThreadPlanStepOverBreakpoint::MischiefManaged() { 142 lldb::addr_t pc_addr = GetThread().GetRegisterContext()->GetPC(); 143 144 if (pc_addr == m_breakpoint_addr) { 145 // If we are still at the PC of our breakpoint, then for some reason we 146 // didn't get a chance to run. 147 return false; 148 } else { 149 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 150 LLDB_LOGF(log, "Completed step over breakpoint plan."); 151 // Otherwise, re-enable the breakpoint we were stepping over, and we're 152 // done. 153 ReenableBreakpointSite(); 154 ThreadPlan::MischiefManaged(); 155 return true; 156 } 157 } 158 159 void ThreadPlanStepOverBreakpoint::ReenableBreakpointSite() { 160 if (!m_reenabled_breakpoint_site) { 161 m_reenabled_breakpoint_site = true; 162 BreakpointSiteSP bp_site_sp( 163 m_process.GetBreakpointSiteList().FindByAddress(m_breakpoint_addr)); 164 if (bp_site_sp) { 165 m_process.EnableBreakpointSite(bp_site_sp.get()); 166 } 167 } 168 } 169 void ThreadPlanStepOverBreakpoint::ThreadDestroyed() { 170 ReenableBreakpointSite(); 171 } 172 173 void ThreadPlanStepOverBreakpoint::SetAutoContinue(bool do_it) { 174 m_auto_continue = do_it; 175 } 176 177 bool ThreadPlanStepOverBreakpoint::ShouldAutoContinue(Event *event_ptr) { 178 return m_auto_continue; 179 } 180 181 bool ThreadPlanStepOverBreakpoint::IsPlanStale() { 182 return GetThread().GetRegisterContext()->GetPC() != m_breakpoint_addr; 183 } 184