contrib/llvm/tools/lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp

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