contrib/llvm-project/lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp

   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
  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 = m_thread.GetRegisterContext()->GetPC();
  34   m_breakpoint_site_id =
  35       m_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
  66     if (log)
  67       log->Printf("Step over breakpoint stopped for reason: %s.",
  68           Thread::StopReasonAsCString(reason));
  69
  70     switch (reason) {
  71       case eStopReasonTrace:
  72       case eStopReasonNone:
  73         return true;
  74       case eStopReasonBreakpoint:
  75       {
  76         // It's a little surprising that we stop here for a breakpoint hit.
  77         // However, when you single step ONTO a breakpoint we still want to call
  78         // that a breakpoint hit, and trigger the actions, etc.  Otherwise you
  79         // would see the PC at the breakpoint without having triggered the
  80         // actions, then you'd continue, the PC wouldn't change, and you'd see
  81         // the breakpoint hit, which would be odd. So the lower levels fake
  82         // "step onto breakpoint address" and return that as a breakpoint hit.
  83         // So our trace step COULD appear as a breakpoint hit if the next
  84         // instruction also contained a breakpoint.  We don't want to handle
  85         // that, since we really don't know what to do with breakpoint hits.
  86         // But make sure we don't set ourselves to auto-continue or we'll wrench
  87         // control away from the plans that can deal with this.
  88         // Be careful, however, as we may have "seen a breakpoint under the PC
  89         // because we stopped without changing the PC, in which case we do want
  90         // to re-claim this stop so we'll try again.
  91         lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
  92
  93         if (pc_addr == m_breakpoint_addr) {
  94           if (log)
  95             log->Printf("Got breakpoint stop reason but pc: 0x%" PRIx64
  96                         "hasn't changed.", pc_addr);
  97           return true;
  98         }
  99
 100         SetAutoContinue(false);
 101         return false;
 102       }
 103       default:
 104         return false;
 105     }
 106   }
 107   return false;
 108 }
 109
 110 bool ThreadPlanStepOverBreakpoint::ShouldStop(Event *event_ptr) {
 111   return !ShouldAutoContinue(event_ptr);
 112 }
 113
 114 bool ThreadPlanStepOverBreakpoint::StopOthers() { return true; }
 115
 116 StateType ThreadPlanStepOverBreakpoint::GetPlanRunState() {
 117   return eStateStepping;
 118 }
 119
 120 bool ThreadPlanStepOverBreakpoint::DoWillResume(StateType resume_state,
 121                                                 bool current_plan) {
 122   if (current_plan) {
 123     BreakpointSiteSP bp_site_sp(
 124         m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress(
 125             m_breakpoint_addr));
 126     if (bp_site_sp && bp_site_sp->IsEnabled()) {
 127       m_thread.GetProcess()->DisableBreakpointSite(bp_site_sp.get());
 128       m_reenabled_breakpoint_site = false;
 129     }
 130   }
 131   return true;
 132 }
 133
 134 bool ThreadPlanStepOverBreakpoint::WillStop() {
 135   ReenableBreakpointSite();
 136   return true;
 137 }
 138
 139 void ThreadPlanStepOverBreakpoint::WillPop() {
 140   ReenableBreakpointSite();
 141 }
 142
 143 bool ThreadPlanStepOverBreakpoint::MischiefManaged() {
 144   lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
 145
 146   if (pc_addr == m_breakpoint_addr) {
 147     // If we are still at the PC of our breakpoint, then for some reason we
 148     // didn't get a chance to run.
 149     return false;
 150   } else {
 151     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 152     if (log)
 153       log->Printf("Completed step over breakpoint plan.");
 154     // Otherwise, re-enable the breakpoint we were stepping over, and we're
 155     // done.
 156     ReenableBreakpointSite();
 157     ThreadPlan::MischiefManaged();
 158     return true;
 159   }
 160 }
 161
 162 void ThreadPlanStepOverBreakpoint::ReenableBreakpointSite() {
 163   if (!m_reenabled_breakpoint_site) {
 164     m_reenabled_breakpoint_site = true;
 165     BreakpointSiteSP bp_site_sp(
 166         m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress(
 167             m_breakpoint_addr));
 168     if (bp_site_sp) {
 169       m_thread.GetProcess()->EnableBreakpointSite(bp_site_sp.get());
 170     }
 171   }
 172 }
 173 void ThreadPlanStepOverBreakpoint::ThreadDestroyed() {
 174   ReenableBreakpointSite();
 175 }
 176
 177 void ThreadPlanStepOverBreakpoint::SetAutoContinue(bool do_it) {
 178   m_auto_continue = do_it;
 179 }
 180
 181 bool ThreadPlanStepOverBreakpoint::ShouldAutoContinue(Event *event_ptr) {
 182   return m_auto_continue;
 183 }
 184
 185 bool ThreadPlanStepOverBreakpoint::IsPlanStale() {
 186   return m_thread.GetRegisterContext()->GetPC() != m_breakpoint_addr;
 187 }