e761213428
This fix really needed to happen as a previous fix I had submitted for calculating symbol sizes made many symbols appear to have zero size since the function that was calculating the symbol size was calling another function that would cause the calculation to happen again. This resulted in some symbols having zero size when they shouldn't. This could then cause infinite stack traces and many other side affects. llvm-svn: 152244
322 lines
10 KiB
C++
322 lines
10 KiB
C++
//===-- ThreadPlanStepInRange.cpp -------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Target/ThreadPlanStepInRange.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
|
|
#include "lldb/lldb-private-log.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Symbol/Symbol.h"
|
|
#include "lldb/Symbol/Function.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Target/ThreadPlanStepOut.h"
|
|
#include "lldb/Target/ThreadPlanStepThrough.h"
|
|
#include "lldb/Core/RegularExpression.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
uint32_t ThreadPlanStepInRange::s_default_flag_values = ThreadPlanShouldStopHere::eAvoidNoDebug;
|
|
|
|
//----------------------------------------------------------------------
|
|
// ThreadPlanStepInRange: Step through a stack range, either stepping over or into
|
|
// based on the value of \a type.
|
|
//----------------------------------------------------------------------
|
|
|
|
ThreadPlanStepInRange::ThreadPlanStepInRange
|
|
(
|
|
Thread &thread,
|
|
const AddressRange &range,
|
|
const SymbolContext &addr_context,
|
|
lldb::RunMode stop_others
|
|
) :
|
|
ThreadPlanStepRange (ThreadPlan::eKindStepInRange, "Step Range stepping in", thread, range, addr_context, stop_others),
|
|
ThreadPlanShouldStopHere (this, ThreadPlanStepInRange::DefaultShouldStopHereCallback, NULL),
|
|
m_step_past_prologue (true)
|
|
{
|
|
SetFlagsToDefault ();
|
|
}
|
|
|
|
ThreadPlanStepInRange::~ThreadPlanStepInRange ()
|
|
{
|
|
}
|
|
|
|
void
|
|
ThreadPlanStepInRange::GetDescription (Stream *s, lldb::DescriptionLevel level)
|
|
{
|
|
if (level == lldb::eDescriptionLevelBrief)
|
|
s->Printf("step in");
|
|
else
|
|
{
|
|
s->Printf ("Stepping through range (stepping into functions): ");
|
|
DumpRanges(s);
|
|
}
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepInRange::PlanExplainsStop ()
|
|
{
|
|
// We always explain a stop. Either we've just done a single step, in which
|
|
// case we'll do our ordinary processing, or we stopped for some
|
|
// reason that isn't handled by our sub-plans, in which case we want to just stop right
|
|
// away.
|
|
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
|
|
StopInfoSP stop_info_sp = GetPrivateStopReason();
|
|
if (stop_info_sp)
|
|
{
|
|
StopReason reason = stop_info_sp->GetStopReason();
|
|
|
|
switch (reason)
|
|
{
|
|
case eStopReasonBreakpoint:
|
|
case eStopReasonWatchpoint:
|
|
case eStopReasonSignal:
|
|
case eStopReasonException:
|
|
if (log)
|
|
log->PutCString ("ThreadPlanStepInRange got asked if it explains the stop for some reason other than step.");
|
|
SetPlanComplete();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepInRange::ShouldStop (Event *event_ptr)
|
|
{
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
|
|
m_no_more_plans = false;
|
|
|
|
if (log)
|
|
{
|
|
StreamString s;
|
|
s.Address (m_thread.GetRegisterContext()->GetPC(),
|
|
m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize());
|
|
log->Printf("ThreadPlanStepInRange reached %s.", s.GetData());
|
|
}
|
|
|
|
if (IsPlanComplete())
|
|
return true;
|
|
|
|
// If we're still in the range, keep going.
|
|
if (InRange())
|
|
return false;
|
|
|
|
ThreadPlan* new_plan = NULL;
|
|
|
|
// Stepping through should be done stopping other threads in general, since we're setting a breakpoint and
|
|
// continuing...
|
|
|
|
bool stop_others;
|
|
if (m_stop_others != lldb::eAllThreads)
|
|
stop_others = true;
|
|
else
|
|
stop_others = false;
|
|
|
|
FrameComparison frame_order = CompareCurrentFrameToStartFrame();
|
|
|
|
if (frame_order == eFrameCompareOlder)
|
|
{
|
|
// If we're in an older frame then we should stop.
|
|
//
|
|
// A caveat to this is if we think the frame is older but we're actually in a trampoline.
|
|
// I'm going to make the assumption that you wouldn't RETURN to a trampoline. So if we are
|
|
// in a trampoline we think the frame is older because the trampoline confused the backtracer.
|
|
new_plan = m_thread.QueueThreadPlanForStepThrough (false, stop_others);
|
|
if (new_plan == NULL)
|
|
return true;
|
|
else if (log)
|
|
{
|
|
log->Printf("Thought I stepped out, but in fact arrived at a trampoline.");
|
|
}
|
|
|
|
}
|
|
else if (frame_order != eFrameCompareYounger && InSymbol())
|
|
{
|
|
// If we are not in a place we should step through, we're done.
|
|
// One tricky bit here is that some stubs don't push a frame, so we have to check
|
|
// both the case of a frame that is younger, or the same as this frame.
|
|
// However, if the frame is the same, and we are still in the symbol we started
|
|
// in, the we don't need to do this. This first check isn't strictly necessary,
|
|
// but it is more efficient.
|
|
|
|
SetPlanComplete();
|
|
return true;
|
|
}
|
|
|
|
// We may have set the plan up above in the FrameIsOlder section:
|
|
|
|
if (new_plan == NULL)
|
|
new_plan = m_thread.QueueThreadPlanForStepThrough (false, stop_others);
|
|
|
|
if (log)
|
|
{
|
|
if (new_plan != NULL)
|
|
log->Printf ("Found a step through plan: %s", new_plan->GetName());
|
|
else
|
|
log->Printf ("No step through plan found.");
|
|
}
|
|
|
|
// If not, give the "should_stop" callback a chance to push a plan to get us out of here.
|
|
// But only do that if we actually have stepped in.
|
|
if (!new_plan && frame_order == eFrameCompareYounger)
|
|
new_plan = InvokeShouldStopHereCallback();
|
|
|
|
// If we've stepped in and we are going to stop here, check to see if we were asked to
|
|
// run past the prologue, and if so do that.
|
|
|
|
if (new_plan == NULL && frame_order == eFrameCompareYounger && m_step_past_prologue)
|
|
{
|
|
lldb::StackFrameSP curr_frame = m_thread.GetStackFrameAtIndex(0);
|
|
if (curr_frame)
|
|
{
|
|
size_t bytes_to_skip = 0;
|
|
lldb::addr_t curr_addr = m_thread.GetRegisterContext()->GetPC();
|
|
Address func_start_address;
|
|
|
|
SymbolContext sc = curr_frame->GetSymbolContext (eSymbolContextFunction | eSymbolContextSymbol);
|
|
|
|
if (sc.function)
|
|
{
|
|
func_start_address = sc.function->GetAddressRange().GetBaseAddress();
|
|
if (curr_addr == func_start_address.GetLoadAddress(m_thread.CalculateTarget().get()))
|
|
bytes_to_skip = sc.function->GetPrologueByteSize();
|
|
}
|
|
else if (sc.symbol)
|
|
{
|
|
func_start_address = sc.symbol->GetAddress();
|
|
if (curr_addr == func_start_address.GetLoadAddress(m_thread.CalculateTarget().get()))
|
|
bytes_to_skip = sc.symbol->GetPrologueByteSize();
|
|
}
|
|
|
|
if (bytes_to_skip != 0)
|
|
{
|
|
func_start_address.Slide (bytes_to_skip);
|
|
log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP);
|
|
if (log)
|
|
log->Printf ("Pushing past prologue ");
|
|
|
|
new_plan = m_thread.QueueThreadPlanForRunToAddress(false, func_start_address,true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (new_plan == NULL)
|
|
{
|
|
m_no_more_plans = true;
|
|
SetPlanComplete();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
m_no_more_plans = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void
|
|
ThreadPlanStepInRange::SetFlagsToDefault ()
|
|
{
|
|
GetFlags().Set(ThreadPlanStepInRange::s_default_flag_values);
|
|
}
|
|
|
|
void
|
|
ThreadPlanStepInRange::SetAvoidRegexp(const char *name)
|
|
{
|
|
if (m_avoid_regexp_ap.get() == NULL)
|
|
m_avoid_regexp_ap.reset (new RegularExpression(name));
|
|
|
|
m_avoid_regexp_ap->Compile (name);
|
|
}
|
|
|
|
void
|
|
ThreadPlanStepInRange::SetDefaultFlagValue (uint32_t new_value)
|
|
{
|
|
// TODO: Should we test this for sanity?
|
|
ThreadPlanStepInRange::s_default_flag_values = new_value;
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepInRange::FrameMatchesAvoidRegexp ()
|
|
{
|
|
StackFrame *frame = GetThread().GetStackFrameAtIndex(0).get();
|
|
|
|
RegularExpression *avoid_regexp_to_use;
|
|
|
|
avoid_regexp_to_use = m_avoid_regexp_ap.get();
|
|
if (avoid_regexp_to_use == NULL)
|
|
avoid_regexp_to_use = GetThread().GetSymbolsToAvoidRegexp();
|
|
|
|
if (avoid_regexp_to_use != NULL)
|
|
{
|
|
SymbolContext sc = frame->GetSymbolContext(eSymbolContextSymbol);
|
|
if (sc.symbol != NULL)
|
|
{
|
|
const char *unnamed_symbol = "<UNKNOWN>";
|
|
const char *sym_name = sc.symbol->GetMangled().GetName().AsCString(unnamed_symbol);
|
|
if (strcmp (sym_name, unnamed_symbol) != 0)
|
|
return avoid_regexp_to_use->Execute(sym_name);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ThreadPlan *
|
|
ThreadPlanStepInRange::DefaultShouldStopHereCallback (ThreadPlan *current_plan, Flags &flags, void *baton)
|
|
{
|
|
bool should_step_out = false;
|
|
StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
|
|
|
|
if (flags.Test(eAvoidNoDebug))
|
|
{
|
|
if (!frame->HasDebugInformation())
|
|
{
|
|
if (log)
|
|
log->Printf ("Stepping out of frame with no debug info");
|
|
|
|
should_step_out = true;
|
|
}
|
|
}
|
|
|
|
if (!should_step_out)
|
|
{
|
|
if (current_plan->GetKind() == eKindStepInRange)
|
|
{
|
|
ThreadPlanStepInRange *step_in_range_plan = static_cast<ThreadPlanStepInRange *> (current_plan);
|
|
should_step_out = step_in_range_plan->FrameMatchesAvoidRegexp ();
|
|
}
|
|
}
|
|
|
|
if (should_step_out)
|
|
{
|
|
// FIXME: Make sure the ThreadPlanForStepOut does the right thing with inlined functions.
|
|
return current_plan->GetThread().QueueThreadPlanForStepOut (false,
|
|
NULL,
|
|
true,
|
|
current_plan->StopOthers(),
|
|
eVoteNo,
|
|
eVoteNoOpinion,
|
|
0); // Frame index
|
|
}
|
|
|
|
return NULL;
|
|
}
|