b44af8ff25
it succeeded, since the plan that was using it can figure out what to do from there. It should only say it failed if it truely went off into the weeds. <rdar://problem/15597807> llvm-svn: 196631
291 lines
8.8 KiB
C++
291 lines
8.8 KiB
C++
//===-- ThreadPlanStepThrough.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/ThreadPlanStepThrough.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/Target/DynamicLoader.h"
|
|
#include "lldb/Target/ObjCLanguageRuntime.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Breakpoint/Breakpoint.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
//----------------------------------------------------------------------
|
|
// ThreadPlanStepThrough: If the current instruction is a trampoline, step through it
|
|
// If it is the beginning of the prologue of a function, step through that as well.
|
|
// FIXME: At present only handles DYLD trampolines.
|
|
//----------------------------------------------------------------------
|
|
|
|
ThreadPlanStepThrough::ThreadPlanStepThrough (Thread &thread, StackID &m_stack_id, bool stop_others) :
|
|
ThreadPlan (ThreadPlan::eKindStepThrough, "Step through trampolines and prologues", thread, eVoteNoOpinion, eVoteNoOpinion),
|
|
m_start_address (0),
|
|
m_backstop_bkpt_id (LLDB_INVALID_BREAK_ID),
|
|
m_backstop_addr(LLDB_INVALID_ADDRESS),
|
|
m_return_stack_id (m_stack_id),
|
|
m_stop_others (stop_others)
|
|
{
|
|
|
|
LookForPlanToStepThroughFromCurrentPC();
|
|
|
|
// If we don't get a valid step through plan, don't bother to set up a backstop.
|
|
if (m_sub_plan_sp)
|
|
{
|
|
m_start_address = GetThread().GetRegisterContext()->GetPC(0);
|
|
|
|
// We are going to return back to the concrete frame 1, we might pass by some inlined code that we're in
|
|
// the middle of by doing this, but it's easier than trying to figure out where the inlined code might return to.
|
|
|
|
StackFrameSP return_frame_sp = m_thread.GetFrameWithStackID (m_stack_id);
|
|
|
|
if (return_frame_sp)
|
|
{
|
|
m_backstop_addr = return_frame_sp->GetFrameCodeAddress().GetLoadAddress(m_thread.CalculateTarget().get());
|
|
Breakpoint *return_bp = m_thread.GetProcess()->GetTarget().CreateBreakpoint (m_backstop_addr, true, false).get();
|
|
if (return_bp != NULL)
|
|
{
|
|
return_bp->SetThreadID(m_thread.GetID());
|
|
m_backstop_bkpt_id = return_bp->GetID();
|
|
return_bp->SetBreakpointKind("step-through-backstop");
|
|
}
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
|
|
if (log)
|
|
{
|
|
log->Printf ("Setting backstop breakpoint %d at address: 0x%" PRIx64, m_backstop_bkpt_id, m_backstop_addr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ThreadPlanStepThrough::~ThreadPlanStepThrough ()
|
|
{
|
|
ClearBackstopBreakpoint ();
|
|
}
|
|
|
|
void
|
|
ThreadPlanStepThrough::DidPush ()
|
|
{
|
|
if (m_sub_plan_sp)
|
|
PushPlan(m_sub_plan_sp);
|
|
}
|
|
|
|
void
|
|
ThreadPlanStepThrough::LookForPlanToStepThroughFromCurrentPC()
|
|
{
|
|
m_sub_plan_sp = m_thread.GetProcess()->GetDynamicLoader()->GetStepThroughTrampolinePlan (m_thread, m_stop_others);
|
|
// If that didn't come up with anything, try the ObjC runtime plugin:
|
|
if (!m_sub_plan_sp.get())
|
|
{
|
|
ObjCLanguageRuntime *objc_runtime = m_thread.GetProcess()->GetObjCLanguageRuntime();
|
|
if (objc_runtime)
|
|
m_sub_plan_sp = objc_runtime->GetStepThroughTrampolinePlan (m_thread, m_stop_others);
|
|
}
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
|
|
if (log)
|
|
{
|
|
lldb::addr_t current_address = GetThread().GetRegisterContext()->GetPC(0);
|
|
if (m_sub_plan_sp)
|
|
{
|
|
StreamString s;
|
|
m_sub_plan_sp->GetDescription(&s, lldb::eDescriptionLevelFull);
|
|
log->Printf ("Found step through plan from 0x%" PRIx64 ": %s", current_address, s.GetData());
|
|
}
|
|
else
|
|
{
|
|
log->Printf ("Couldn't find step through plan from address 0x%" PRIx64 ".", current_address);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ThreadPlanStepThrough::GetDescription (Stream *s, lldb::DescriptionLevel level)
|
|
{
|
|
if (level == lldb::eDescriptionLevelBrief)
|
|
s->Printf ("Step through");
|
|
else
|
|
{
|
|
s->PutCString ("Stepping through trampoline code from: ");
|
|
s->Address(m_start_address, sizeof (addr_t));
|
|
if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID)
|
|
{
|
|
s->Printf (" with backstop breakpoint id: %d at address: ", m_backstop_bkpt_id);
|
|
s->Address (m_backstop_addr, sizeof (addr_t));
|
|
}
|
|
else
|
|
s->PutCString (" unable to set a backstop breakpoint.");
|
|
}
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepThrough::ValidatePlan (Stream *error)
|
|
{
|
|
return m_sub_plan_sp.get() != NULL;
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepThrough::DoPlanExplainsStop (Event *event_ptr)
|
|
{
|
|
// If we have a sub-plan, it will have been asked first if we explain the stop, and
|
|
// we won't get asked. The only time we would be the one directly asked this question
|
|
// is if we hit our backstop breakpoint.
|
|
|
|
if (HitOurBackstopBreakpoint())
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepThrough::ShouldStop (Event *event_ptr)
|
|
{
|
|
// If we've already marked ourselves done, then we're done...
|
|
if (IsPlanComplete())
|
|
return true;
|
|
|
|
// First, did we hit the backstop breakpoint?
|
|
if (HitOurBackstopBreakpoint())
|
|
{
|
|
SetPlanComplete(true);
|
|
return true;
|
|
}
|
|
|
|
// If we don't have a sub-plan, then we're also done (can't see how we would ever get here
|
|
// without a plan, but just in case.
|
|
|
|
if (!m_sub_plan_sp)
|
|
{
|
|
SetPlanComplete();
|
|
return true;
|
|
}
|
|
|
|
// If the current sub plan is not done, we don't want to stop. Actually, we probably won't
|
|
// ever get here in this state, since we generally won't get asked any questions if out
|
|
// current sub-plan is not done...
|
|
if (!m_sub_plan_sp->IsPlanComplete())
|
|
return false;
|
|
|
|
// If our current sub plan failed, then let's just run to our backstop. If we can't do that then just stop.
|
|
if (!m_sub_plan_sp->PlanSucceeded())
|
|
{
|
|
if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID)
|
|
{
|
|
m_sub_plan_sp.reset();
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
SetPlanComplete(false);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Next see if there is a specific step through plan at our current pc (these might
|
|
// chain, for instance stepping through a dylib trampoline to the objc dispatch function...)
|
|
LookForPlanToStepThroughFromCurrentPC();
|
|
if (m_sub_plan_sp)
|
|
{
|
|
PushPlan (m_sub_plan_sp);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
SetPlanComplete();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepThrough::StopOthers ()
|
|
{
|
|
return m_stop_others;
|
|
}
|
|
|
|
StateType
|
|
ThreadPlanStepThrough::GetPlanRunState ()
|
|
{
|
|
return eStateRunning;
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepThrough::DoWillResume (StateType resume_state, bool current_plan)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepThrough::WillStop ()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void
|
|
ThreadPlanStepThrough::ClearBackstopBreakpoint ()
|
|
{
|
|
if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID)
|
|
{
|
|
m_thread.GetProcess()->GetTarget().RemoveBreakpointByID (m_backstop_bkpt_id);
|
|
m_backstop_bkpt_id = LLDB_INVALID_BREAK_ID;
|
|
}
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepThrough::MischiefManaged ()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
|
|
|
|
if (!IsPlanComplete())
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (log)
|
|
log->Printf("Completed step through step plan.");
|
|
|
|
ClearBackstopBreakpoint ();
|
|
ThreadPlan::MischiefManaged ();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool
|
|
ThreadPlanStepThrough::HitOurBackstopBreakpoint()
|
|
{
|
|
StopInfoSP stop_info_sp(m_thread.GetStopInfo());
|
|
if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint)
|
|
{
|
|
break_id_t stop_value = (break_id_t) stop_info_sp->GetValue();
|
|
BreakpointSiteSP cur_site_sp = m_thread.GetProcess()->GetBreakpointSiteList().FindByID(stop_value);
|
|
if (cur_site_sp && cur_site_sp->IsBreakpointAtThisSite(m_backstop_bkpt_id))
|
|
{
|
|
StackID cur_frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
|
|
|
|
if (cur_frame_zero_id == m_return_stack_id)
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
|
|
if (log)
|
|
log->PutCString ("ThreadPlanStepThrough hit backstop breakpoint.");
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|