ThreadPlanStepOverRange.cpp revision 2bcbaf625afd8f521da03ddaa146e7ea7650ee38
1//===-- ThreadPlanStepOverRange.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/ThreadPlanStepOverRange.h" 11 12// C Includes 13// C++ Includes 14// Other libraries and framework includes 15// Project includes 16 17#include "lldb/lldb-private-log.h" 18#include "lldb/Core/Log.h" 19#include "lldb/Core/Stream.h" 20#include "lldb/Target/Process.h" 21#include "lldb/Target/RegisterContext.h" 22#include "lldb/Target/Target.h" 23#include "lldb/Target/Thread.h" 24#include "lldb/Target/ThreadPlanStepOut.h" 25#include "lldb/Target/ThreadPlanStepThrough.h" 26 27using namespace lldb_private; 28using namespace lldb; 29 30 31//---------------------------------------------------------------------- 32// ThreadPlanStepOverRange: Step through a stack range, either stepping over or into 33// based on the value of \a type. 34//---------------------------------------------------------------------- 35 36ThreadPlanStepOverRange::ThreadPlanStepOverRange 37( 38 Thread &thread, 39 const AddressRange &range, 40 const SymbolContext &addr_context, 41 lldb::RunMode stop_others, 42 bool okay_to_discard 43) : 44 ThreadPlanStepRange (ThreadPlan::eKindStepOverRange, "Step range stepping over", thread, range, addr_context, stop_others) 45{ 46 // Step over range plans can be master plans, since you could hit a breakpoint while stepping over, step around 47 // a bit, then continue to finish up the step over. 48 SetIsMasterPlan (true); 49 SetOkayToDiscard (okay_to_discard); 50} 51 52ThreadPlanStepOverRange::~ThreadPlanStepOverRange () 53{ 54} 55 56void 57ThreadPlanStepOverRange::GetDescription (Stream *s, lldb::DescriptionLevel level) 58{ 59 if (level == lldb::eDescriptionLevelBrief) 60 s->Printf("step over"); 61 else 62 { 63 s->Printf ("stepping through range (stepping over functions): "); 64 DumpRanges(s); 65 } 66} 67 68bool 69ThreadPlanStepOverRange::ShouldStop (Event *event_ptr) 70{ 71 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 72 73 if (log) 74 { 75 StreamString s; 76 s.Address (m_thread.GetRegisterContext()->GetPC(), 77 m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize()); 78 log->Printf("ThreadPlanStepOverRange reached %s.", s.GetData()); 79 } 80 81 // If we're out of the range but in the same frame or in our caller's frame 82 // then we should stop. 83 // When stepping out we only step if we are forcing running one thread. 84 bool stop_others; 85 if (m_stop_others == lldb::eOnlyThisThread) 86 stop_others = true; 87 else 88 stop_others = false; 89 90 ThreadPlan* new_plan = NULL; 91 92 FrameComparison frame_order = CompareCurrentFrameToStartFrame(); 93 94 if (frame_order == eFrameCompareOlder) 95 { 96 // If we're in an older frame then we should stop. 97 // 98 // A caveat to this is if we think the frame is older but we're actually in a trampoline. 99 // I'm going to make the assumption that you wouldn't RETURN to a trampoline. So if we are 100 // in a trampoline we think the frame is older because the trampoline confused the backtracer. 101 // As below, we step through first, and then try to figure out how to get back out again. 102 103 new_plan = m_thread.QueueThreadPlanForStepThrough (false, stop_others); 104 105 if (new_plan != NULL && log) 106 log->Printf("Thought I stepped out, but in fact arrived at a trampoline."); 107 } 108 else if (frame_order == eFrameCompareYounger) 109 { 110 // Make sure we really are in a new frame. Do that by unwinding and seeing if the 111 // start function really is our start function... 112 StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(1); 113 114 // But if we can't even unwind one frame we should just get out of here & stop... 115 if (older_frame_sp) 116 { 117 const SymbolContext &older_context = older_frame_sp->GetSymbolContext(eSymbolContextEverything); 118 if (older_context == m_addr_context) 119 { 120 new_plan = m_thread.QueueThreadPlanForStepOut (false, 121 NULL, 122 true, 123 stop_others, 124 eVoteNo, 125 eVoteNoOpinion, 126 0); 127 } 128 else 129 { 130 new_plan = m_thread.QueueThreadPlanForStepThrough (false, stop_others); 131 132 } 133 } 134 } 135 else 136 { 137 // If we're still in the range, keep going. 138 if (InRange()) 139 { 140 SetNextBranchBreakpoint(); 141 return false; 142 } 143 144 145 if (!InSymbol()) 146 { 147 // This one is a little tricky. Sometimes we may be in a stub or something similar, 148 // in which case we need to get out of there. But if we are in a stub then it's 149 // likely going to be hard to get out from here. It is probably easiest to step into the 150 // stub, and then it will be straight-forward to step out. 151 new_plan = m_thread.QueueThreadPlanForStepThrough (false, stop_others); 152 } 153 } 154 155 // If we get to this point, we're not going to use a previously set "next branch" breakpoint, so delete it: 156 ClearNextBranchBreakpoint(); 157 158 if (new_plan == NULL) 159 m_no_more_plans = true; 160 else 161 m_no_more_plans = false; 162 163 if (new_plan == NULL) 164 { 165 // For efficiencies sake, we know we're done here so we don't have to do this 166 // calculation again in MischiefManaged. 167 SetPlanComplete(); 168 return true; 169 } 170 else 171 return false; 172} 173