3c8e9499ac
On Darwin, clang added a new objc class method dispatch, turned on by the flag: `-fobjc-msgsend-class-selector-stubs`. These stubs are like the accelerated stubs added previously for method selectors. This patch adds support for stepping through them. I had previously handled the method stubs by figuring out the object -> class and then used the selector encoded in the stub name. But that depended on all the stubs setting the object into arg1 before calling the stub, which not all the stubs do anymore. Since all the stubs do some work and then call objc_msgSend, instead of trying to predict what the stub is going to do, I just let it run to the objc_msgSend and then figure out how to go from there - at that point arg1 and arg2 are correctly set, so I can use the regular objc_msgSend trampoline for that. That change meant I was no longer using the "find the implementation" method that was passing in the selector string that we pulled from the stub name, so this patch also removes that.
425 lines
16 KiB
C++
425 lines
16 KiB
C++
//===-- AppleThreadPlanStepThroughObjCTrampoline.cpp-----------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "AppleThreadPlanStepThroughObjCTrampoline.h"
|
|
|
|
#include "AppleObjCTrampolineHandler.h"
|
|
#include "lldb/Expression/DiagnosticManager.h"
|
|
#include "lldb/Expression/FunctionCaller.h"
|
|
#include "lldb/Expression/UtilityFunction.h"
|
|
#include "lldb/Target/ABI.h"
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Target/ThreadPlanRunToAddress.h"
|
|
#include "lldb/Target/ThreadPlanStepOut.h"
|
|
#include "lldb/Utility/LLDBLog.h"
|
|
#include "lldb/Utility/Log.h"
|
|
|
|
#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
|
|
|
|
#include <memory>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
// ThreadPlanStepThroughObjCTrampoline constructor
|
|
AppleThreadPlanStepThroughObjCTrampoline::
|
|
AppleThreadPlanStepThroughObjCTrampoline(
|
|
Thread &thread, AppleObjCTrampolineHandler &trampoline_handler,
|
|
ValueList &input_values, lldb::addr_t isa_addr, lldb::addr_t sel_addr,
|
|
lldb::addr_t sel_str_addr, llvm::StringRef sel_str)
|
|
: 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(nullptr),
|
|
m_sel_str_addr(sel_str_addr), m_sel_str(sel_str) {}
|
|
|
|
// Destructor
|
|
AppleThreadPlanStepThroughObjCTrampoline::
|
|
~AppleThreadPlanStepThroughObjCTrampoline() = default;
|
|
|
|
void AppleThreadPlanStepThroughObjCTrampoline::DidPush() {
|
|
// Setting up the memory space for the called function text might require
|
|
// allocations, i.e. a nested function call. This needs to be done as a
|
|
// PreResumeAction.
|
|
m_process.AddPreResumeAction(PreResumeInitializeFunctionCaller, (void *)this);
|
|
}
|
|
|
|
bool AppleThreadPlanStepThroughObjCTrampoline::InitializeFunctionCaller() {
|
|
if (!m_func_sp) {
|
|
DiagnosticManager diagnostics;
|
|
m_args_addr =
|
|
m_trampoline_handler.SetupDispatchFunction(GetThread(), m_input_values);
|
|
|
|
if (m_args_addr == LLDB_INVALID_ADDRESS) {
|
|
return false;
|
|
}
|
|
m_impl_function =
|
|
m_trampoline_handler.GetLookupImplementationFunctionCaller();
|
|
ExecutionContext exc_ctx;
|
|
EvaluateExpressionOptions options;
|
|
options.SetUnwindOnError(true);
|
|
options.SetIgnoreBreakpoints(true);
|
|
options.SetStopOthers(false);
|
|
GetThread().CalculateExecutionContext(exc_ctx);
|
|
m_func_sp = m_impl_function->GetThreadPlanToCallFunction(
|
|
exc_ctx, m_args_addr, options, diagnostics);
|
|
m_func_sp->SetOkayToDiscard(true);
|
|
PushPlan(m_func_sp);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool AppleThreadPlanStepThroughObjCTrampoline::
|
|
PreResumeInitializeFunctionCaller(void *void_myself) {
|
|
AppleThreadPlanStepThroughObjCTrampoline *myself =
|
|
static_cast<AppleThreadPlanStepThroughObjCTrampoline *>(void_myself);
|
|
return myself->InitializeFunctionCaller();
|
|
}
|
|
|
|
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::DoPlanExplainsStop(
|
|
Event *event_ptr) {
|
|
// If we get asked to explain the stop it will be because something went
|
|
// wrong (like the implementation for selector function crashed... We're
|
|
// going to figure out what to do about that, so we do explain the stop.
|
|
return true;
|
|
}
|
|
|
|
lldb::StateType AppleThreadPlanStepThroughObjCTrampoline::GetPlanRunState() {
|
|
return eStateRunning;
|
|
}
|
|
|
|
bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) {
|
|
// First stage: we are still handling the "call a function to get the target
|
|
// of the dispatch"
|
|
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();
|
|
}
|
|
}
|
|
|
|
// Second stage, if all went well with the function calling, get the
|
|
// implementation function address, and queue up a "run to that address" plan.
|
|
Log *log = GetLog(LLDBLog::Step);
|
|
|
|
if (!m_run_to_sp) {
|
|
Value target_addr_value;
|
|
ExecutionContext exc_ctx;
|
|
GetThread().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();
|
|
|
|
if (ABISP abi_sp = GetThread().GetProcess()->GetABI()) {
|
|
target_addr = abi_sp->FixCodeAddress(target_addr);
|
|
}
|
|
Address target_so_addr;
|
|
target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr());
|
|
if (target_addr == 0) {
|
|
LLDB_LOGF(log, "Got target implementation of 0x0, stopping.");
|
|
SetPlanComplete();
|
|
return true;
|
|
}
|
|
if (m_trampoline_handler.AddrIsMsgForward(target_addr)) {
|
|
LLDB_LOGF(log,
|
|
"Implementation lookup returned msgForward function: 0x%" PRIx64
|
|
", stopping.",
|
|
target_addr);
|
|
|
|
SymbolContext sc = GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(
|
|
eSymbolContextEverything);
|
|
Status status;
|
|
const bool abort_other_plans = false;
|
|
const bool first_insn = true;
|
|
const uint32_t frame_idx = 0;
|
|
m_run_to_sp = GetThread().QueueThreadPlanForStepOutNoShouldStop(
|
|
abort_other_plans, &sc, first_insn, false, eVoteNoOpinion,
|
|
eVoteNoOpinion, frame_idx, status);
|
|
if (m_run_to_sp && status.Success())
|
|
m_run_to_sp->SetPrivate(true);
|
|
return false;
|
|
}
|
|
|
|
LLDB_LOGF(log, "Running to ObjC method implementation: 0x%" PRIx64,
|
|
target_addr);
|
|
|
|
ObjCLanguageRuntime *objc_runtime =
|
|
ObjCLanguageRuntime::Get(*GetThread().GetProcess());
|
|
assert(objc_runtime != nullptr);
|
|
if (m_sel_str_addr != LLDB_INVALID_ADDRESS) {
|
|
// Cache the string -> implementation and free the string in the target.
|
|
Status dealloc_error =
|
|
GetThread().GetProcess()->DeallocateMemory(m_sel_str_addr);
|
|
// For now just log this:
|
|
if (dealloc_error.Fail())
|
|
LLDB_LOG(log, "Failed to deallocate the sel str at {0} - error: {1}",
|
|
m_sel_str_addr, dealloc_error);
|
|
objc_runtime->AddToMethodCache(m_isa_addr, m_sel_str, target_addr);
|
|
LLDB_LOG(log,
|
|
"Adding \\{isa-addr={0}, sel-addr={1}\\} = addr={2} to cache.",
|
|
m_isa_addr, m_sel_str, target_addr);
|
|
} else {
|
|
objc_runtime->AddToMethodCache(m_isa_addr, m_sel_addr, target_addr);
|
|
LLDB_LOGF(log,
|
|
"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 = std::make_shared<ThreadPlanRunToAddress>(
|
|
GetThread(), target_so_addr, false);
|
|
PushPlan(m_run_to_sp);
|
|
return false;
|
|
} else if (GetThread().IsThreadPlanDone(m_run_to_sp.get())) {
|
|
// Third stage, work the run to target plan.
|
|
SetPlanComplete();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// The base class MischiefManaged does some cleanup - so you have to call it in
|
|
// your MischiefManaged derived class.
|
|
bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() {
|
|
return IsPlanComplete();
|
|
}
|
|
|
|
bool AppleThreadPlanStepThroughObjCTrampoline::WillStop() { return true; }
|
|
|
|
// Objective-C uses optimized dispatch functions for some common and seldom
|
|
// overridden methods. For instance
|
|
// [object respondsToSelector:];
|
|
// will get compiled to:
|
|
// objc_opt_respondsToSelector(object);
|
|
// This checks whether the selector has been overridden, directly calling the
|
|
// implementation if it hasn't and calling objc_msgSend if it has.
|
|
//
|
|
// We need to get into the overridden implementation. We'll do that by
|
|
// setting a breakpoint on objc_msgSend, and doing a "step out". If we stop
|
|
// at objc_msgSend, we can step through to the target of the send, and see if
|
|
// that's a place we want to stop.
|
|
//
|
|
// A couple of complexities. The checking code might call some other method,
|
|
// so we might see objc_msgSend more than once. Also, these optimized dispatch
|
|
// functions might dispatch more than one message at a time (e.g. alloc followed
|
|
// by init.) So we can't give up at the first objc_msgSend.
|
|
// That means among other things that we have to handle the "ShouldStopHere" -
|
|
// since we can't just return control to the plan that's controlling us on the
|
|
// first step.
|
|
|
|
AppleThreadPlanStepThroughDirectDispatch ::
|
|
AppleThreadPlanStepThroughDirectDispatch(
|
|
Thread &thread, AppleObjCTrampolineHandler &handler)
|
|
: ThreadPlanStepOut(thread, nullptr, true /* first instruction */, false,
|
|
eVoteNoOpinion, eVoteNoOpinion,
|
|
0 /* Step out of zeroth frame */,
|
|
eLazyBoolNo /* Our parent plan will decide this
|
|
when we are done */
|
|
,
|
|
true /* Run to branch for inline step out */,
|
|
false /* Don't gather the return value */),
|
|
m_trampoline_handler(handler), m_at_msg_send(false) {
|
|
// Set breakpoints on the dispatch functions:
|
|
auto bkpt_callback = [&] (lldb::addr_t addr,
|
|
const AppleObjCTrampolineHandler
|
|
::DispatchFunction &dispatch) {
|
|
m_msgSend_bkpts.push_back(GetTarget().CreateBreakpoint(addr,
|
|
true /* internal */,
|
|
false /* hard */));
|
|
m_msgSend_bkpts.back()->SetThreadID(GetThread().GetID());
|
|
};
|
|
handler.ForEachDispatchFunction(bkpt_callback);
|
|
|
|
// We'll set the step-out plan in the DidPush so it gets queued in the right
|
|
// order.
|
|
|
|
if (GetThread().GetStepInAvoidsNoDebug())
|
|
GetFlags().Set(ThreadPlanShouldStopHere::eStepInAvoidNoDebug);
|
|
else
|
|
GetFlags().Clear(ThreadPlanShouldStopHere::eStepInAvoidNoDebug);
|
|
// We only care about step in. Our parent plan will figure out what to
|
|
// do when we've stepped out again.
|
|
GetFlags().Clear(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
|
|
}
|
|
|
|
AppleThreadPlanStepThroughDirectDispatch::
|
|
~AppleThreadPlanStepThroughDirectDispatch() {
|
|
for (BreakpointSP bkpt_sp : m_msgSend_bkpts) {
|
|
GetTarget().RemoveBreakpointByID(bkpt_sp->GetID());
|
|
}
|
|
}
|
|
|
|
void AppleThreadPlanStepThroughDirectDispatch::GetDescription(
|
|
Stream *s, lldb::DescriptionLevel level) {
|
|
switch (level) {
|
|
case lldb::eDescriptionLevelBrief:
|
|
s->PutCString("Step through ObjC direct dispatch function.");
|
|
break;
|
|
default:
|
|
s->Printf("Step through ObjC direct dispatch using breakpoints: ");
|
|
bool first = true;
|
|
for (auto bkpt_sp : m_msgSend_bkpts) {
|
|
if (!first) {
|
|
s->PutCString(", ");
|
|
}
|
|
first = false;
|
|
s->Printf("%d", bkpt_sp->GetID());
|
|
}
|
|
(*s) << ".";
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool
|
|
AppleThreadPlanStepThroughDirectDispatch::DoPlanExplainsStop(Event *event_ptr) {
|
|
if (ThreadPlanStepOut::DoPlanExplainsStop(event_ptr))
|
|
return true;
|
|
|
|
StopInfoSP stop_info_sp = GetPrivateStopInfo();
|
|
|
|
// Check if the breakpoint is one of ours msgSend dispatch breakpoints.
|
|
|
|
StopReason stop_reason = eStopReasonNone;
|
|
if (stop_info_sp)
|
|
stop_reason = stop_info_sp->GetStopReason();
|
|
|
|
// See if this is one of our msgSend breakpoints:
|
|
if (stop_reason == eStopReasonBreakpoint) {
|
|
ProcessSP process_sp = GetThread().GetProcess();
|
|
uint64_t break_site_id = stop_info_sp->GetValue();
|
|
BreakpointSiteSP site_sp
|
|
= process_sp->GetBreakpointSiteList().FindByID(break_site_id);
|
|
// Some other plan might have deleted the site's last owner before this
|
|
// got to us. In which case, it wasn't our breakpoint...
|
|
if (!site_sp)
|
|
return false;
|
|
|
|
for (BreakpointSP break_sp : m_msgSend_bkpts) {
|
|
if (site_sp->IsBreakpointAtThisSite(break_sp->GetID())) {
|
|
// If we aren't the only one with a breakpoint on this site, then we
|
|
// should just stop and return control to the user.
|
|
if (site_sp->GetNumberOfConstituents() > 1) {
|
|
SetPlanComplete(true);
|
|
return false;
|
|
}
|
|
m_at_msg_send = true;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// We're done here. If one of our sub-plans explained the stop, they
|
|
// would have already answered true to PlanExplainsStop, and if they were
|
|
// done, we'll get called to figure out what to do in ShouldStop...
|
|
return false;
|
|
}
|
|
|
|
bool AppleThreadPlanStepThroughDirectDispatch
|
|
::DoWillResume(lldb::StateType resume_state, bool current_plan) {
|
|
ThreadPlanStepOut::DoWillResume(resume_state, current_plan);
|
|
m_at_msg_send = false;
|
|
return true;
|
|
}
|
|
|
|
bool AppleThreadPlanStepThroughDirectDispatch::ShouldStop(Event *event_ptr) {
|
|
// If step out plan finished, that means we didn't find our way into a method
|
|
// implementation. Either we went directly to the default implementation,
|
|
// of the overridden implementation didn't have debug info.
|
|
// So we should mark ourselves as done.
|
|
const bool step_out_should_stop = ThreadPlanStepOut::ShouldStop(event_ptr);
|
|
if (step_out_should_stop) {
|
|
SetPlanComplete(true);
|
|
return true;
|
|
}
|
|
|
|
// If we have a step through plan, then w're in the process of getting
|
|
// through an ObjC msgSend. If we arrived at the target function, then
|
|
// check whether we have debug info, and if we do, stop.
|
|
Log *log = GetLog(LLDBLog::Step);
|
|
|
|
if (m_objc_step_through_sp && m_objc_step_through_sp->IsPlanComplete()) {
|
|
// If the plan failed for some reason, we should probably just let the
|
|
// step over plan get us out of here... We don't need to do anything about
|
|
// the step through plan, it is done and will get popped when we continue.
|
|
if (!m_objc_step_through_sp->PlanSucceeded()) {
|
|
LLDB_LOGF(log, "ObjC Step through plan failed. Stepping out.");
|
|
}
|
|
Status error;
|
|
if (InvokeShouldStopHereCallback(eFrameCompareYounger, error)) {
|
|
SetPlanComplete(true);
|
|
return true;
|
|
}
|
|
// If we didn't want to stop at this msgSend, there might be another so
|
|
// we should just continue on with the step out and see if our breakpoint
|
|
// triggers again.
|
|
m_objc_step_through_sp.reset();
|
|
for (BreakpointSP bkpt_sp : m_msgSend_bkpts) {
|
|
bkpt_sp->SetEnabled(true);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// If we hit an msgSend breakpoint, then we should queue the step through
|
|
// plan:
|
|
|
|
if (m_at_msg_send) {
|
|
LanguageRuntime *objc_runtime
|
|
= GetThread().GetProcess()->GetLanguageRuntime(eLanguageTypeObjC);
|
|
// There's no way we could have gotten here without an ObjC language
|
|
// runtime.
|
|
assert(objc_runtime);
|
|
m_objc_step_through_sp =
|
|
objc_runtime->GetStepThroughTrampolinePlan(GetThread(), false);
|
|
// If we failed to find the target for this dispatch, just keep going and
|
|
// let the step out complete.
|
|
if (!m_objc_step_through_sp) {
|
|
LLDB_LOG(log, "Couldn't find target for message dispatch, continuing.");
|
|
return false;
|
|
}
|
|
// Otherwise push the step through plan and continue.
|
|
GetThread().QueueThreadPlan(m_objc_step_through_sp, false);
|
|
for (BreakpointSP bkpt_sp : m_msgSend_bkpts) {
|
|
bkpt_sp->SetEnabled(false);
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool AppleThreadPlanStepThroughDirectDispatch::MischiefManaged() {
|
|
if (IsPlanComplete())
|
|
return true;
|
|
return ThreadPlanStepOut::MischiefManaged();
|
|
}
|