1 //===-- ThreadPlanStepInRange.cpp -------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Target/ThreadPlanStepInRange.h"
14 // Other libraries and framework includes
17 #include "lldb/lldb-private-log.h"
18 #include "lldb/Core/Log.h"
19 #include "lldb/Core/Module.h"
20 #include "lldb/Core/Stream.h"
21 #include "lldb/Symbol/Symbol.h"
22 #include "lldb/Symbol/Function.h"
23 #include "lldb/Target/Process.h"
24 #include "lldb/Target/RegisterContext.h"
25 #include "lldb/Target/Target.h"
26 #include "lldb/Target/Thread.h"
27 #include "lldb/Target/ThreadPlanStepOut.h"
28 #include "lldb/Target/ThreadPlanStepThrough.h"
29 #include "lldb/Core/RegularExpression.h"
32 using namespace lldb_private;
34 uint32_t ThreadPlanStepInRange::s_default_flag_values = ThreadPlanShouldStopHere::eAvoidNoDebug;
36 //----------------------------------------------------------------------
37 // ThreadPlanStepInRange: Step through a stack range, either stepping over or into
38 // based on the value of \a type.
39 //----------------------------------------------------------------------
41 ThreadPlanStepInRange::ThreadPlanStepInRange
44 const AddressRange &range,
45 const SymbolContext &addr_context,
46 lldb::RunMode stop_others
48 ThreadPlanStepRange (ThreadPlan::eKindStepInRange, "Step Range stepping in", thread, range, addr_context, stop_others),
49 ThreadPlanShouldStopHere (this, ThreadPlanStepInRange::DefaultShouldStopHereCallback, NULL),
50 m_step_past_prologue (true),
51 m_virtual_step (false)
56 ThreadPlanStepInRange::ThreadPlanStepInRange
59 const AddressRange &range,
60 const SymbolContext &addr_context,
61 const char *step_into_target,
62 lldb::RunMode stop_others
64 ThreadPlanStepRange (ThreadPlan::eKindStepInRange, "Step Range stepping in", thread, range, addr_context, stop_others),
65 ThreadPlanShouldStopHere (this, ThreadPlanStepInRange::DefaultShouldStopHereCallback, NULL),
66 m_step_past_prologue (true),
67 m_virtual_step (false),
68 m_step_into_target (step_into_target)
73 ThreadPlanStepInRange::~ThreadPlanStepInRange ()
78 ThreadPlanStepInRange::GetDescription (Stream *s, lldb::DescriptionLevel level)
80 if (level == lldb::eDescriptionLevelBrief)
84 s->Printf ("Stepping through range (stepping into functions): ");
86 const char *step_into_target = m_step_into_target.AsCString();
87 if (step_into_target && step_into_target[0] != '\0')
88 s->Printf (" targeting %s.", m_step_into_target.AsCString());
95 ThreadPlanStepInRange::ShouldStop (Event *event_ptr)
97 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
102 s.Address (m_thread.GetRegisterContext()->GetPC(),
103 m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize());
104 log->Printf("ThreadPlanStepInRange reached %s.", s.GetData());
107 if (IsPlanComplete())
110 m_no_more_plans = false;
111 if (m_sub_plan_sp && m_sub_plan_sp->IsPlanComplete())
113 if (!m_sub_plan_sp->PlanSucceeded())
116 m_no_more_plans = true;
120 m_sub_plan_sp.reset();
125 // If we've just completed a virtual step, all we need to do is check for a ShouldStopHere plan, and otherwise
127 m_sub_plan_sp = InvokeShouldStopHereCallback();
131 // Stepping through should be done running other threads in general, since we're setting a breakpoint and
132 // continuing. So only stop others if we are explicitly told to do so.
135 if (m_stop_others == lldb::eOnlyThisThread)
140 FrameComparison frame_order = CompareCurrentFrameToStartFrame();
142 if (frame_order == eFrameCompareOlder)
144 // If we're in an older frame then we should stop.
146 // A caveat to this is if we think the frame is older but we're actually in a trampoline.
147 // I'm going to make the assumption that you wouldn't RETURN to a trampoline. So if we are
148 // in a trampoline we think the frame is older because the trampoline confused the backtracer.
149 m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough (m_stack_id, false, stop_others);
154 log->Printf("Thought I stepped out, but in fact arrived at a trampoline.");
158 else if (frame_order == eFrameCompareEqual && InSymbol())
160 // If we are not in a place we should step through, we're done.
161 // One tricky bit here is that some stubs don't push a frame, so we have to check
162 // both the case of a frame that is younger, or the same as this frame.
163 // However, if the frame is the same, and we are still in the symbol we started
164 // in, the we don't need to do this. This first check isn't strictly necessary,
165 // but it is more efficient.
167 // If we're still in the range, keep going, either by running to the next branch breakpoint, or by
171 SetNextBranchBreakpoint();
176 m_no_more_plans = true;
180 // If we get to this point, we're not going to use a previously set "next branch" breakpoint, so delete it:
181 ClearNextBranchBreakpoint();
183 // We may have set the plan up above in the FrameIsOlder section:
186 m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough (m_stack_id, false, stop_others);
191 log->Printf ("Found a step through plan: %s", m_sub_plan_sp->GetName());
193 log->Printf ("No step through plan found.");
196 // If not, give the "should_stop" callback a chance to push a plan to get us out of here.
197 // But only do that if we actually have stepped in.
198 if (!m_sub_plan_sp && frame_order == eFrameCompareYounger)
199 m_sub_plan_sp = InvokeShouldStopHereCallback();
201 // If we've stepped in and we are going to stop here, check to see if we were asked to
202 // run past the prologue, and if so do that.
204 if (!m_sub_plan_sp && frame_order == eFrameCompareYounger && m_step_past_prologue)
206 lldb::StackFrameSP curr_frame = m_thread.GetStackFrameAtIndex(0);
209 size_t bytes_to_skip = 0;
210 lldb::addr_t curr_addr = m_thread.GetRegisterContext()->GetPC();
211 Address func_start_address;
213 SymbolContext sc = curr_frame->GetSymbolContext (eSymbolContextFunction | eSymbolContextSymbol);
217 func_start_address = sc.function->GetAddressRange().GetBaseAddress();
218 if (curr_addr == func_start_address.GetLoadAddress(m_thread.CalculateTarget().get()))
219 bytes_to_skip = sc.function->GetPrologueByteSize();
223 func_start_address = sc.symbol->GetAddress();
224 if (curr_addr == func_start_address.GetLoadAddress(m_thread.CalculateTarget().get()))
225 bytes_to_skip = sc.symbol->GetPrologueByteSize();
228 if (bytes_to_skip != 0)
230 func_start_address.Slide (bytes_to_skip);
231 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP);
233 log->Printf ("Pushing past prologue ");
235 m_sub_plan_sp = m_thread.QueueThreadPlanForRunToAddress(false, func_start_address,true);
243 m_no_more_plans = true;
249 m_no_more_plans = false;
255 ThreadPlanStepInRange::SetFlagsToDefault ()
257 GetFlags().Set(ThreadPlanStepInRange::s_default_flag_values);
261 ThreadPlanStepInRange::SetAvoidRegexp(const char *name)
263 if (m_avoid_regexp_ap.get() == NULL)
264 m_avoid_regexp_ap.reset (new RegularExpression(name));
266 m_avoid_regexp_ap->Compile (name);
270 ThreadPlanStepInRange::SetDefaultFlagValue (uint32_t new_value)
272 // TODO: Should we test this for sanity?
273 ThreadPlanStepInRange::s_default_flag_values = new_value;
277 ThreadPlanStepInRange::FrameMatchesAvoidCriteria ()
279 StackFrame *frame = GetThread().GetStackFrameAtIndex(0).get();
281 // Check the library list first, as that's cheapest:
282 bool libraries_say_avoid = false;
284 FileSpecList libraries_to_avoid (GetThread().GetLibrariesToAvoid());
285 size_t num_libraries = libraries_to_avoid.GetSize();
286 if (num_libraries > 0)
288 SymbolContext sc(frame->GetSymbolContext(eSymbolContextModule));
289 FileSpec frame_library(sc.module_sp->GetFileSpec());
293 for (size_t i = 0; i < num_libraries; i++)
295 const FileSpec &file_spec(libraries_to_avoid.GetFileSpecAtIndex(i));
296 if (FileSpec::Equal (file_spec, frame_library, false))
298 libraries_say_avoid = true;
304 if (libraries_say_avoid)
307 const RegularExpression *avoid_regexp_to_use = m_avoid_regexp_ap.get();
308 if (avoid_regexp_to_use == NULL)
309 avoid_regexp_to_use = GetThread().GetSymbolsToAvoidRegexp();
311 if (avoid_regexp_to_use != NULL)
313 SymbolContext sc = frame->GetSymbolContext(eSymbolContextFunction|eSymbolContextBlock|eSymbolContextSymbol);
314 if (sc.symbol != NULL)
316 const char *frame_function_name = sc.GetFunctionName().GetCString();
317 if (frame_function_name)
319 size_t num_matches = 0;
320 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
324 RegularExpression::Match regex_match(num_matches);
326 bool return_value = avoid_regexp_to_use->Execute(frame_function_name, ®ex_match);
332 regex_match.GetMatchAtIndex(frame_function_name,0, match);
333 log->Printf ("Stepping out of function \"%s\" because it matches the avoid regexp \"%s\" - match substring: \"%s\".",
335 avoid_regexp_to_use->GetText(),
348 ThreadPlanStepInRange::DefaultShouldStopHereCallback (ThreadPlan *current_plan, Flags &flags, void *baton)
350 bool should_step_out = false;
351 StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
352 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
354 if (flags.Test(eAvoidNoDebug))
356 if (!frame->HasDebugInformation())
359 log->Printf ("Stepping out of frame with no debug info");
361 should_step_out = true;
365 if (current_plan->GetKind() == eKindStepInRange)
367 ThreadPlanStepInRange *step_in_range_plan = static_cast<ThreadPlanStepInRange *> (current_plan);
368 if (step_in_range_plan->m_step_into_target)
370 SymbolContext sc = frame->GetSymbolContext(eSymbolContextFunction|eSymbolContextBlock|eSymbolContextSymbol);
371 if (sc.symbol != NULL)
373 // First try an exact match, since that's cheap with ConstStrings. Then do a strstr compare.
374 if (step_in_range_plan->m_step_into_target == sc.GetFunctionName())
376 should_step_out = false;
380 const char *target_name = step_in_range_plan->m_step_into_target.AsCString();
381 const char *function_name = sc.GetFunctionName().AsCString();
383 if (function_name == NULL)
384 should_step_out = true;
385 else if (strstr (function_name, target_name) == NULL)
386 should_step_out = true;
388 if (log && should_step_out)
389 log->Printf("Stepping out of frame %s which did not match step into target %s.",
390 sc.GetFunctionName().AsCString(),
391 step_in_range_plan->m_step_into_target.AsCString());
395 if (!should_step_out)
397 ThreadPlanStepInRange *step_in_range_plan = static_cast<ThreadPlanStepInRange *> (current_plan);
398 // Don't log the should_step_out here, it's easier to do it in FrameMatchesAvoidCriteria.
399 should_step_out = step_in_range_plan->FrameMatchesAvoidCriteria ();
406 // FIXME: Make sure the ThreadPlanForStepOut does the right thing with inlined functions.
407 // We really should have all plans take the tri-state for "stop others" so we can do the right
408 // thing. For now let's be safe and always run others when we are likely to run arbitrary code.
409 const bool stop_others = false;
410 return current_plan->GetThread().QueueThreadPlanForStepOut (false,
419 return ThreadPlanSP();
423 ThreadPlanStepInRange::DoPlanExplainsStop (Event *event_ptr)
425 // We always explain a stop. Either we've just done a single step, in which
426 // case we'll do our ordinary processing, or we stopped for some
427 // reason that isn't handled by our sub-plans, in which case we want to just stop right
429 // In general, we don't want to mark the plan as complete for unexplained stops.
430 // For instance, if you step in to some code with no debug info, so you step out
431 // and in the course of that hit a breakpoint, then you want to stop & show the user
432 // the breakpoint, but not unship the step in plan, since you still may want to complete that
433 // plan when you continue. This is particularly true when doing "step in to target function."
436 // The only variation is that if we are doing "step by running to next branch" in which case
437 // if we hit our branch breakpoint we don't set the plan to complete.
447 StopInfoSP stop_info_sp = GetPrivateStopInfo ();
450 StopReason reason = stop_info_sp->GetStopReason();
454 case eStopReasonBreakpoint:
455 if (NextRangeBreakpointExplainsStop(stop_info_sp))
460 case eStopReasonWatchpoint:
461 case eStopReasonSignal:
462 case eStopReasonException:
463 case eStopReasonExec:
464 case eStopReasonThreadExiting:
466 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
468 log->PutCString ("ThreadPlanStepInRange got asked if it explains the stop for some reason other than step.");
470 return_value = false;
485 ThreadPlanStepInRange::DoWillResume (lldb::StateType resume_state, bool current_plan)
487 if (resume_state == eStateStepping && current_plan)
489 // See if we are about to step over a virtual inlined call.
490 bool step_without_resume = m_thread.DecrementCurrentInlinedDepth();
491 if (step_without_resume)
493 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
495 log->Printf ("ThreadPlanStepInRange::DoWillResume: returning false, inline_depth: %d",
496 m_thread.GetCurrentInlinedDepth());
497 SetStopInfo(StopInfo::CreateStopReasonToTrace(m_thread));
499 // FIXME: Maybe it would be better to create a InlineStep stop reason, but then
500 // the whole rest of the world would have to handle that stop reason.
501 m_virtual_step = true;
503 return !step_without_resume;
509 ThreadPlanStepInRange::IsVirtualStep()
511 return m_virtual_step;