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

   1 //===-- ThreadPlanStepThrough.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/ThreadPlanStepThrough.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/DynamicLoader.h"
  20 #include "lldb/Target/ObjCLanguageRuntime.h"
  21 #include "lldb/Target/Process.h"
  22 #include "lldb/Target/RegisterContext.h"
  23 #include "lldb/Target/Target.h"
  24 #include "lldb/Breakpoint/Breakpoint.h"
  25
  26 using namespace lldb;
  27 using namespace lldb_private;
  28
  29 //----------------------------------------------------------------------
  30 // ThreadPlanStepThrough: If the current instruction is a trampoline, step through it
  31 // If it is the beginning of the prologue of a function, step through that as well.
  32 // FIXME: At present only handles DYLD trampolines.
  33 //----------------------------------------------------------------------
  34
  35 ThreadPlanStepThrough::ThreadPlanStepThrough (Thread &thread, StackID &m_stack_id, bool stop_others) :
  36     ThreadPlan (ThreadPlan::eKindStepThrough, "Step through trampolines and prologues", thread, eVoteNoOpinion, eVoteNoOpinion),
  37     m_start_address (0),
  38     m_backstop_bkpt_id (LLDB_INVALID_BREAK_ID),
  39     m_backstop_addr(LLDB_INVALID_ADDRESS),
  40     m_return_stack_id (m_stack_id),
  41     m_stop_others (stop_others)
  42 {
  43
  44     LookForPlanToStepThroughFromCurrentPC();
  45
  46     // If we don't get a valid step through plan, don't bother to set up a backstop.
  47     if (m_sub_plan_sp)
  48     {
  49         m_start_address = GetThread().GetRegisterContext()->GetPC(0);
  50
  51         // We are going to return back to the concrete frame 1, we might pass by some inlined code that we're in
  52         // the middle of by doing this, but it's easier than trying to figure out where the inlined code might return to.
  53
  54         StackFrameSP return_frame_sp = m_thread.GetFrameWithStackID (m_stack_id);
  55
  56         if (return_frame_sp)
  57         {
  58             m_backstop_addr = return_frame_sp->GetFrameCodeAddress().GetLoadAddress(m_thread.CalculateTarget().get());
  59             Breakpoint *return_bp = m_thread.GetProcess()->GetTarget().CreateBreakpoint (m_backstop_addr, true, false).get();
  60             if (return_bp != NULL)
  61             {
  62                 return_bp->SetThreadID(m_thread.GetID());
  63                 m_backstop_bkpt_id = return_bp->GetID();
  64                 return_bp->SetBreakpointKind("step-through-backstop");
  65             }
  66             Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
  67             if (log)
  68             {
  69                 log->Printf ("Setting backstop breakpoint %d at address: 0x%" PRIx64, m_backstop_bkpt_id, m_backstop_addr);
  70             }
  71         }
  72     }
  73 }
  74
  75 ThreadPlanStepThrough::~ThreadPlanStepThrough ()
  76 {
  77     ClearBackstopBreakpoint ();
  78 }
  79
  80 void
  81 ThreadPlanStepThrough::DidPush ()
  82 {
  83     if (m_sub_plan_sp)
  84         PushPlan(m_sub_plan_sp);
  85 }
  86
  87 void
  88 ThreadPlanStepThrough::LookForPlanToStepThroughFromCurrentPC()
  89 {
  90     m_sub_plan_sp = m_thread.GetProcess()->GetDynamicLoader()->GetStepThroughTrampolinePlan (m_thread, m_stop_others);
  91     // If that didn't come up with anything, try the ObjC runtime plugin:
  92     if (!m_sub_plan_sp.get())
  93     {
  94         ObjCLanguageRuntime *objc_runtime = m_thread.GetProcess()->GetObjCLanguageRuntime();
  95         if (objc_runtime)
  96             m_sub_plan_sp = objc_runtime->GetStepThroughTrampolinePlan (m_thread, m_stop_others);
  97     }
  98
  99     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 100     if (log)
 101     {
 102         lldb::addr_t current_address = GetThread().GetRegisterContext()->GetPC(0);
 103         if (m_sub_plan_sp)
 104         {
 105             StreamString s;
 106             m_sub_plan_sp->GetDescription(&s, lldb::eDescriptionLevelFull);
 107             log->Printf ("Found step through plan from 0x%" PRIx64 ": %s", current_address, s.GetData());
 108         }
 109         else
 110         {
 111             log->Printf ("Couldn't find step through plan from address 0x%" PRIx64 ".", current_address);
 112         }
 113     }
 114 }
 115
 116 void
 117 ThreadPlanStepThrough::GetDescription (Stream *s, lldb::DescriptionLevel level)
 118 {
 119     if (level == lldb::eDescriptionLevelBrief)
 120         s->Printf ("Step through");
 121     else
 122     {
 123         s->PutCString ("Stepping through trampoline code from: ");
 124         s->Address(m_start_address, sizeof (addr_t));
 125         if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID)
 126         {
 127             s->Printf (" with backstop breakpoint id: %d at address: ", m_backstop_bkpt_id);
 128             s->Address (m_backstop_addr, sizeof (addr_t));
 129         }
 130         else
 131             s->PutCString (" unable to set a backstop breakpoint.");
 132     }
 133 }
 134
 135 bool
 136 ThreadPlanStepThrough::ValidatePlan (Stream *error)
 137 {
 138     return m_sub_plan_sp.get() != NULL;
 139 }
 140
 141 bool
 142 ThreadPlanStepThrough::DoPlanExplainsStop (Event *event_ptr)
 143 {
 144     // If we have a sub-plan, it will have been asked first if we explain the stop, and
 145     // we won't get asked.  The only time we would be the one directly asked this question
 146     // is if we hit our backstop breakpoint.
 147
 148     if (HitOurBackstopBreakpoint())
 149         return true;
 150     else
 151         return false;
 152 }
 153
 154 bool
 155 ThreadPlanStepThrough::ShouldStop (Event *event_ptr)
 156 {
 157     // If we've already marked ourselves done, then we're done...
 158     if (IsPlanComplete())
 159         return true;
 160
 161     // First, did we hit the backstop breakpoint?
 162     if (HitOurBackstopBreakpoint())
 163     {
 164         SetPlanComplete(true);
 165         return true;
 166     }
 167
 168     // If we don't have a sub-plan, then we're also done (can't see how we would ever get here
 169     // without a plan, but just in case.
 170
 171     if (!m_sub_plan_sp)
 172     {
 173         SetPlanComplete();
 174         return true;
 175     }
 176
 177     // If the current sub plan is not done, we don't want to stop.  Actually, we probably won't
 178     // ever get here in this state, since we generally won't get asked any questions if out
 179     // current sub-plan is not done...
 180     if (!m_sub_plan_sp->IsPlanComplete())
 181         return false;
 182
 183     // If our current sub plan failed, then let's just run to our backstop.  If we can't do that then just stop.
 184     if (!m_sub_plan_sp->PlanSucceeded())
 185     {
 186         if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID)
 187         {
 188             m_sub_plan_sp.reset();
 189             return false;
 190         }
 191         else
 192         {
 193             SetPlanComplete(false);
 194             return true;
 195         }
 196     }
 197
 198     // Next see if there is a specific step through plan at our current pc (these might
 199     // chain, for instance stepping through a dylib trampoline to the objc dispatch function...)
 200     LookForPlanToStepThroughFromCurrentPC();
 201     if (m_sub_plan_sp)
 202     {
 203         PushPlan (m_sub_plan_sp);
 204         return false;
 205     }
 206     else
 207     {
 208         SetPlanComplete();
 209         return true;
 210     }
 211 }
 212
 213 bool
 214 ThreadPlanStepThrough::StopOthers ()
 215 {
 216     return m_stop_others;
 217 }
 218
 219 StateType
 220 ThreadPlanStepThrough::GetPlanRunState ()
 221 {
 222     return eStateRunning;
 223 }
 224
 225 bool
 226 ThreadPlanStepThrough::DoWillResume (StateType resume_state, bool current_plan)
 227 {
 228     return true;
 229 }
 230
 231 bool
 232 ThreadPlanStepThrough::WillStop ()
 233 {
 234     return true;
 235 }
 236
 237 void
 238 ThreadPlanStepThrough::ClearBackstopBreakpoint ()
 239 {
 240     if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID)
 241     {
 242         m_thread.GetProcess()->GetTarget().RemoveBreakpointByID (m_backstop_bkpt_id);
 243         m_backstop_bkpt_id = LLDB_INVALID_BREAK_ID;
 244     }
 245 }
 246
 247 bool
 248 ThreadPlanStepThrough::MischiefManaged ()
 249 {
 250     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 251
 252     if (!IsPlanComplete())
 253     {
 254         return false;
 255     }
 256     else
 257     {
 258         if (log)
 259             log->Printf("Completed step through step plan.");
 260
 261         ClearBackstopBreakpoint ();
 262         ThreadPlan::MischiefManaged ();
 263         return true;
 264     }
 265 }
 266
 267 bool
 268 ThreadPlanStepThrough::HitOurBackstopBreakpoint()
 269 {
 270     StopInfoSP stop_info_sp(m_thread.GetStopInfo());
 271     if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint)
 272     {
 273         break_id_t stop_value = (break_id_t) stop_info_sp->GetValue();
 274         BreakpointSiteSP cur_site_sp = m_thread.GetProcess()->GetBreakpointSiteList().FindByID(stop_value);
 275         if (cur_site_sp && cur_site_sp->IsBreakpointAtThisSite(m_backstop_bkpt_id))
 276         {
 277             StackID cur_frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
 278
 279             if (cur_frame_zero_id == m_return_stack_id)
 280             {
 281                 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 282                 if (log)
 283                     log->PutCString ("ThreadPlanStepThrough hit backstop breakpoint.");
 284                 return true;
 285             }
 286         }
 287     }
 288     return false;
 289 }
 290