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