AppleThreadPlanStepThroughObjCTrampoline.cpp [plain text]
#include "AppleThreadPlanStepThroughObjCTrampoline.h"
#include "AppleObjCTrampolineHandler.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h"
#include "lldb/Expression/ClangExpression.h"
#include "lldb/Expression/ClangFunction.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/ThreadPlanRunToAddress.h"
#include "lldb/Target/ThreadPlanStepOut.h"
#include "lldb/Core/Log.h"
using namespace lldb;
using namespace lldb_private;
AppleThreadPlanStepThroughObjCTrampoline::AppleThreadPlanStepThroughObjCTrampoline
(
Thread &thread,
AppleObjCTrampolineHandler *trampoline_handler,
ValueList &input_values,
lldb::addr_t isa_addr,
lldb::addr_t sel_addr,
bool stop_others
) :
ThreadPlan (ThreadPlan::eKindGeneric,
"MacOSX Step through ObjC Trampoline",
thread,
eVoteNoOpinion,
eVoteNoOpinion),
m_trampoline_handler (trampoline_handler),
m_args_addr (LLDB_INVALID_ADDRESS),
m_input_values (input_values),
m_isa_addr(isa_addr),
m_sel_addr(sel_addr),
m_impl_function (NULL),
m_stop_others (stop_others)
{
}
AppleThreadPlanStepThroughObjCTrampoline::~AppleThreadPlanStepThroughObjCTrampoline()
{
}
void
AppleThreadPlanStepThroughObjCTrampoline::DidPush ()
{
m_thread.GetProcess()->AddPreResumeAction (PreResumeInitializeClangFunction, (void *) this);
}
bool
AppleThreadPlanStepThroughObjCTrampoline::InitializeClangFunction ()
{
if (!m_func_sp)
{
StreamString errors;
m_args_addr = m_trampoline_handler->SetupDispatchFunction(m_thread, m_input_values);
if (m_args_addr == LLDB_INVALID_ADDRESS)
{
return false;
}
m_impl_function = m_trampoline_handler->GetLookupImplementationWrapperFunction();
ExecutionContext exc_ctx;
m_thread.CalculateExecutionContext(exc_ctx);
m_func_sp.reset(m_impl_function->GetThreadPlanToCallFunction (exc_ctx, m_args_addr, errors, m_stop_others));
m_func_sp->SetPrivate(true);
m_func_sp->SetOkayToDiscard(true);
m_thread.QueueThreadPlan (m_func_sp, false);
}
return true;
}
bool
AppleThreadPlanStepThroughObjCTrampoline::PreResumeInitializeClangFunction(void *void_myself)
{
AppleThreadPlanStepThroughObjCTrampoline *myself = static_cast<AppleThreadPlanStepThroughObjCTrampoline *>(void_myself);
return myself->InitializeClangFunction();
}
void
AppleThreadPlanStepThroughObjCTrampoline::GetDescription (Stream *s,
lldb::DescriptionLevel level)
{
if (level == lldb::eDescriptionLevelBrief)
s->Printf("Step through ObjC trampoline");
else
{
s->Printf ("Stepping to implementation of ObjC method - obj: 0x%llx, isa: 0x%" PRIx64 ", sel: 0x%" PRIx64,
m_input_values.GetValueAtIndex(0)->GetScalar().ULongLong(), m_isa_addr, m_sel_addr);
}
}
bool
AppleThreadPlanStepThroughObjCTrampoline::ValidatePlan (Stream *error)
{
return true;
}
bool
AppleThreadPlanStepThroughObjCTrampoline::PlanExplainsStop ()
{
return true;
}
lldb::StateType
AppleThreadPlanStepThroughObjCTrampoline::GetPlanRunState ()
{
return eStateRunning;
}
bool
AppleThreadPlanStepThroughObjCTrampoline::ShouldStop (Event *event_ptr)
{
if (m_func_sp)
{
if (!m_func_sp->IsPlanComplete())
{
return false;
}
else
{
if (!m_func_sp->PlanSucceeded())
{
SetPlanComplete(false);
return true;
}
m_func_sp.reset();
}
}
if (!m_run_to_sp)
{
Value target_addr_value;
ExecutionContext exc_ctx;
m_thread.CalculateExecutionContext(exc_ctx);
m_impl_function->FetchFunctionResults (exc_ctx, m_args_addr, target_addr_value);
m_impl_function->DeallocateFunctionResults(exc_ctx, m_args_addr);
lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong();
Address target_so_addr;
target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr());
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
if (target_addr == 0)
{
if (log)
log->Printf("Got target implementation of 0x0, stopping.");
SetPlanComplete();
return true;
}
if (m_trampoline_handler->AddrIsMsgForward(target_addr))
{
if (log)
log->Printf ("Implementation lookup returned msgForward function: 0x%" PRIx64 ", stopping.", target_addr);
SymbolContext sc = m_thread.GetStackFrameAtIndex(0)->GetSymbolContext(eSymbolContextEverything);
m_run_to_sp.reset(new ThreadPlanStepOut (m_thread,
&sc,
true,
m_stop_others,
eVoteNoOpinion,
eVoteNoOpinion,
0));
m_thread.QueueThreadPlan(m_run_to_sp, false);
m_run_to_sp->SetPrivate(true);
return false;
}
if (log)
log->Printf("Running to ObjC method implementation: 0x%" PRIx64, target_addr);
ObjCLanguageRuntime *objc_runtime = GetThread().GetProcess()->GetObjCLanguageRuntime();
assert (objc_runtime != NULL);
objc_runtime->AddToMethodCache (m_isa_addr, m_sel_addr, target_addr);
if (log)
log->Printf("Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64 "} = addr=0x%" PRIx64 " to cache.", m_isa_addr, m_sel_addr, target_addr);
m_run_to_sp.reset(new ThreadPlanRunToAddress(m_thread, target_so_addr, m_stop_others));
m_thread.QueueThreadPlan(m_run_to_sp, false);
m_run_to_sp->SetPrivate(true);
return false;
}
else if (m_thread.IsThreadPlanDone(m_run_to_sp.get()))
{
SetPlanComplete();
return true;
}
return false;
}
bool
AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged ()
{
if (IsPlanComplete())
return true;
else
return false;
}
bool
AppleThreadPlanStepThroughObjCTrampoline::WillStop()
{
return true;
}