429 lines · cpp
1//===-- AppleThreadPlanStepThroughObjCTrampoline.cpp-----------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "AppleThreadPlanStepThroughObjCTrampoline.h"10 11#include "AppleObjCTrampolineHandler.h"12#include "lldb/Expression/DiagnosticManager.h"13#include "lldb/Expression/FunctionCaller.h"14#include "lldb/Expression/UtilityFunction.h"15#include "lldb/Target/ABI.h"16#include "lldb/Target/ExecutionContext.h"17#include "lldb/Target/Process.h"18#include "lldb/Target/Thread.h"19#include "lldb/Target/ThreadPlanRunToAddress.h"20#include "lldb/Target/ThreadPlanStepOut.h"21#include "lldb/Utility/LLDBLog.h"22#include "lldb/Utility/Log.h"23 24#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"25 26#include <memory>27 28using namespace lldb;29using namespace lldb_private;30 31// ThreadPlanStepThroughObjCTrampoline constructor32AppleThreadPlanStepThroughObjCTrampoline::33 AppleThreadPlanStepThroughObjCTrampoline(34 Thread &thread, AppleObjCTrampolineHandler &trampoline_handler,35 ValueList &input_values, lldb::addr_t isa_addr, lldb::addr_t sel_addr,36 lldb::addr_t sel_str_addr, llvm::StringRef sel_str)37 : ThreadPlan(ThreadPlan::eKindGeneric,38 "MacOSX Step through ObjC Trampoline", thread, eVoteNoOpinion,39 eVoteNoOpinion),40 m_trampoline_handler(trampoline_handler),41 m_args_addr(LLDB_INVALID_ADDRESS), m_input_values(input_values),42 m_isa_addr(isa_addr), m_sel_addr(sel_addr), m_impl_function(nullptr),43 m_sel_str_addr(sel_str_addr), m_sel_str(sel_str) {}44 45// Destructor46AppleThreadPlanStepThroughObjCTrampoline::47 ~AppleThreadPlanStepThroughObjCTrampoline() = default;48 49void AppleThreadPlanStepThroughObjCTrampoline::DidPush() {50 // Setting up the memory space for the called function text might require51 // allocations, i.e. a nested function call. This needs to be done as a52 // PreResumeAction.53 m_process.AddPreResumeAction(PreResumeInitializeFunctionCaller, (void *)this);54}55 56bool AppleThreadPlanStepThroughObjCTrampoline::InitializeFunctionCaller() {57 if (!m_func_sp) {58 DiagnosticManager diagnostics;59 m_args_addr =60 m_trampoline_handler.SetupDispatchFunction(GetThread(), m_input_values);61 62 if (m_args_addr == LLDB_INVALID_ADDRESS) {63 return false;64 }65 m_impl_function =66 m_trampoline_handler.GetLookupImplementationFunctionCaller();67 ExecutionContext exc_ctx;68 EvaluateExpressionOptions options;69 options.SetUnwindOnError(true);70 options.SetIgnoreBreakpoints(true);71 options.SetStopOthers(false);72 GetThread().CalculateExecutionContext(exc_ctx);73 m_func_sp = m_impl_function->GetThreadPlanToCallFunction(74 exc_ctx, m_args_addr, options, diagnostics);75 m_func_sp->SetOkayToDiscard(true);76 PushPlan(m_func_sp);77 }78 return true;79}80 81bool AppleThreadPlanStepThroughObjCTrampoline::82 PreResumeInitializeFunctionCaller(void *void_myself) {83 AppleThreadPlanStepThroughObjCTrampoline *myself =84 static_cast<AppleThreadPlanStepThroughObjCTrampoline *>(void_myself);85 return myself->InitializeFunctionCaller();86}87 88void AppleThreadPlanStepThroughObjCTrampoline::GetDescription(89 Stream *s, lldb::DescriptionLevel level) {90 if (level == lldb::eDescriptionLevelBrief)91 s->Printf("Step through ObjC trampoline");92 else {93 s->Printf("Stepping to implementation of ObjC method - obj: 0x%llx, isa: "94 "0x%" PRIx64 ", sel: 0x%" PRIx64,95 m_input_values.GetValueAtIndex(0)->GetScalar().ULongLong(),96 m_isa_addr, m_sel_addr);97 }98}99 100bool AppleThreadPlanStepThroughObjCTrampoline::ValidatePlan(Stream *error) {101 return true;102}103 104bool AppleThreadPlanStepThroughObjCTrampoline::DoPlanExplainsStop(105 Event *event_ptr) {106 // If we get asked to explain the stop it will be because something went107 // wrong (like the implementation for selector function crashed... We're108 // going to figure out what to do about that, so we do explain the stop.109 return true;110}111 112lldb::StateType AppleThreadPlanStepThroughObjCTrampoline::GetPlanRunState() {113 return eStateRunning;114}115 116bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) {117 // First stage: we are still handling the "call a function to get the target118 // of the dispatch"119 if (m_func_sp) {120 if (!m_func_sp->IsPlanComplete()) {121 return false;122 } else {123 if (!m_func_sp->PlanSucceeded()) {124 SetPlanComplete(false);125 return true;126 }127 m_func_sp.reset();128 }129 }130 131 // Second stage, if all went well with the function calling, get the132 // implementation function address, and queue up a "run to that address" plan.133 Log *log = GetLog(LLDBLog::Step);134 135 if (!m_run_to_sp) {136 Value target_addr_value;137 ExecutionContext exc_ctx;138 GetThread().CalculateExecutionContext(exc_ctx);139 m_impl_function->FetchFunctionResults(exc_ctx, m_args_addr,140 target_addr_value);141 m_impl_function->DeallocateFunctionResults(exc_ctx, m_args_addr);142 lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong();143 144 if (ABISP abi_sp = GetThread().GetProcess()->GetABI()) {145 target_addr = abi_sp->FixCodeAddress(target_addr);146 }147 Address target_so_addr;148 target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr());149 if (target_addr == 0) {150 LLDB_LOGF(log, "Got target implementation of 0x0, stopping.");151 SetPlanComplete();152 return true;153 }154 if (m_trampoline_handler.AddrIsMsgForward(target_addr)) {155 LLDB_LOGF(log,156 "Implementation lookup returned msgForward function: 0x%" PRIx64157 ", stopping.",158 target_addr);159 160 SymbolContext sc = GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(161 eSymbolContextEverything);162 Status status;163 const bool abort_other_plans = false;164 const bool first_insn = true;165 const uint32_t frame_idx = 0;166 m_run_to_sp = GetThread().QueueThreadPlanForStepOutNoShouldStop(167 abort_other_plans, &sc, first_insn, false, eVoteNoOpinion,168 eVoteNoOpinion, frame_idx, status);169 if (m_run_to_sp && status.Success())170 m_run_to_sp->SetPrivate(true);171 return false;172 }173 174 LLDB_LOGF(log, "Running to ObjC method implementation: 0x%" PRIx64,175 target_addr);176 177 ObjCLanguageRuntime *objc_runtime =178 ObjCLanguageRuntime::Get(*GetThread().GetProcess());179 assert(objc_runtime != nullptr);180 if (m_sel_str_addr != LLDB_INVALID_ADDRESS) {181 // Cache the string -> implementation and free the string in the target.182 Status dealloc_error =183 GetThread().GetProcess()->DeallocateMemory(m_sel_str_addr);184 // For now just log this:185 if (dealloc_error.Fail())186 LLDB_LOG(log, "Failed to deallocate the sel str at {0} - error: {1}",187 m_sel_str_addr, dealloc_error);188 objc_runtime->AddToMethodCache(m_isa_addr, m_sel_str, target_addr);189 LLDB_LOG(log,190 "Adding \\{isa-addr={0}, sel-addr={1}\\} = addr={2} to cache.",191 m_isa_addr, m_sel_str, target_addr);192 } else {193 objc_runtime->AddToMethodCache(m_isa_addr, m_sel_addr, target_addr);194 LLDB_LOGF(log,195 "Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64196 "} = addr=0x%" PRIx64 " to cache.",197 m_isa_addr, m_sel_addr, target_addr);198 }199 200 m_run_to_sp = std::make_shared<ThreadPlanRunToAddress>(201 GetThread(), target_so_addr, false);202 PushPlan(m_run_to_sp);203 return false;204 } else if (GetThread().IsThreadPlanDone(m_run_to_sp.get())) {205 // Third stage, work the run to target plan.206 SetPlanComplete();207 return true;208 }209 return false;210}211 212// The base class MischiefManaged does some cleanup - so you have to call it in213// your MischiefManaged derived class.214bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() {215 return IsPlanComplete();216}217 218bool AppleThreadPlanStepThroughObjCTrampoline::WillStop() { return true; }219 220// Objective-C uses optimized dispatch functions for some common and seldom221// overridden methods. For instance222// [object respondsToSelector:];223// will get compiled to:224// objc_opt_respondsToSelector(object);225// This checks whether the selector has been overridden, directly calling the226// implementation if it hasn't and calling objc_msgSend if it has.227//228// We need to get into the overridden implementation. We'll do that by 229// setting a breakpoint on objc_msgSend, and doing a "step out". If we stop230// at objc_msgSend, we can step through to the target of the send, and see if231// that's a place we want to stop.232//233// A couple of complexities. The checking code might call some other method,234// so we might see objc_msgSend more than once. Also, these optimized dispatch235// functions might dispatch more than one message at a time (e.g. alloc followed236// by init.) So we can't give up at the first objc_msgSend.237// That means among other things that we have to handle the "ShouldStopHere" - 238// since we can't just return control to the plan that's controlling us on the239// first step.240 241AppleThreadPlanStepThroughDirectDispatch ::242 AppleThreadPlanStepThroughDirectDispatch(243 Thread &thread, AppleObjCTrampolineHandler &handler,244 llvm::StringRef dispatch_func_name)245 : ThreadPlanStepOut(thread, nullptr, true /* first instruction */, false,246 eVoteNoOpinion, eVoteNoOpinion,247 0 /* Step out of zeroth frame */,248 eLazyBoolNo /* Our parent plan will decide this249 when we are done */250 ,251 true /* Run to branch for inline step out */,252 false /* Don't gather the return value */),253 m_trampoline_handler(handler),254 m_dispatch_func_name(std::string(dispatch_func_name)),255 m_at_msg_send(false) {256 // Set breakpoints on the dispatch functions:257 auto bkpt_callback = [&] (lldb::addr_t addr, 258 const AppleObjCTrampolineHandler259 ::DispatchFunction &dispatch) {260 m_msgSend_bkpts.push_back(GetTarget().CreateBreakpoint(addr,261 true /* internal */,262 false /* hard */));263 m_msgSend_bkpts.back()->SetThreadID(GetThread().GetID());264 };265 handler.ForEachDispatchFunction(bkpt_callback);266 267 // We'll set the step-out plan in the DidPush so it gets queued in the right268 // order.269 270 if (GetThread().GetStepInAvoidsNoDebug())271 GetFlags().Set(ThreadPlanShouldStopHere::eStepInAvoidNoDebug);272 else273 GetFlags().Clear(ThreadPlanShouldStopHere::eStepInAvoidNoDebug);274 // We only care about step in. Our parent plan will figure out what to275 // do when we've stepped out again.276 GetFlags().Clear(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);277}278 279AppleThreadPlanStepThroughDirectDispatch::280 ~AppleThreadPlanStepThroughDirectDispatch() {281 for (BreakpointSP bkpt_sp : m_msgSend_bkpts) {282 GetTarget().RemoveBreakpointByID(bkpt_sp->GetID());283 }284}285 286void AppleThreadPlanStepThroughDirectDispatch::GetDescription(287 Stream *s, lldb::DescriptionLevel level) {288 switch (level) {289 case lldb::eDescriptionLevelBrief:290 s->PutCString("Step through ObjC direct dispatch function.");291 break;292 default:293 s->Printf("Step through ObjC direct dispatch '%s' using breakpoints: ",294 m_dispatch_func_name.c_str());295 bool first = true;296 for (auto bkpt_sp : m_msgSend_bkpts) {297 if (!first) {298 s->PutCString(", ");299 }300 first = false;301 s->Printf("%d", bkpt_sp->GetID());302 }303 (*s) << "."; 304 break;305 }306}307 308bool 309AppleThreadPlanStepThroughDirectDispatch::DoPlanExplainsStop(Event *event_ptr) {310 if (ThreadPlanStepOut::DoPlanExplainsStop(event_ptr))311 return true;312 313 StopInfoSP stop_info_sp = GetPrivateStopInfo();314 315 // Check if the breakpoint is one of ours msgSend dispatch breakpoints.316 317 StopReason stop_reason = eStopReasonNone;318 if (stop_info_sp)319 stop_reason = stop_info_sp->GetStopReason();320 321 // See if this is one of our msgSend breakpoints:322 if (stop_reason == eStopReasonBreakpoint) {323 ProcessSP process_sp = GetThread().GetProcess();324 uint64_t break_site_id = stop_info_sp->GetValue();325 BreakpointSiteSP site_sp 326 = process_sp->GetBreakpointSiteList().FindByID(break_site_id);327 // Some other plan might have deleted the site's last owner before this 328 // got to us. In which case, it wasn't our breakpoint... 329 if (!site_sp)330 return false;331 332 for (BreakpointSP break_sp : m_msgSend_bkpts) {333 if (site_sp->IsBreakpointAtThisSite(break_sp->GetID())) {334 // If we aren't the only one with a breakpoint on this site, then we335 // should just stop and return control to the user.336 if (site_sp->GetNumberOfConstituents() > 1) {337 SetPlanComplete(true);338 return false;339 }340 m_at_msg_send = true;341 return true;342 }343 }344 }345 346 // We're done here. If one of our sub-plans explained the stop, they 347 // would have already answered true to PlanExplainsStop, and if they were348 // done, we'll get called to figure out what to do in ShouldStop...349 return false;350}351 352bool AppleThreadPlanStepThroughDirectDispatch353 ::DoWillResume(lldb::StateType resume_state, bool current_plan) {354 ThreadPlanStepOut::DoWillResume(resume_state, current_plan);355 m_at_msg_send = false;356 return true;357}358 359bool AppleThreadPlanStepThroughDirectDispatch::ShouldStop(Event *event_ptr) {360 // If step out plan finished, that means we didn't find our way into a method361 // implementation. Either we went directly to the default implementation, 362 // of the overridden implementation didn't have debug info. 363 // So we should mark ourselves as done.364 const bool step_out_should_stop = ThreadPlanStepOut::ShouldStop(event_ptr);365 if (step_out_should_stop) {366 SetPlanComplete(true);367 return true;368 }369 370 // If we have a step through plan, then w're in the process of getting 371 // through an ObjC msgSend. If we arrived at the target function, then 372 // check whether we have debug info, and if we do, stop.373 Log *log = GetLog(LLDBLog::Step);374 375 if (m_objc_step_through_sp && m_objc_step_through_sp->IsPlanComplete()) {376 // If the plan failed for some reason, we should probably just let the377 // step over plan get us out of here... We don't need to do anything about378 // the step through plan, it is done and will get popped when we continue.379 if (!m_objc_step_through_sp->PlanSucceeded()) {380 LLDB_LOGF(log, "ObjC Step through plan failed. Stepping out.");381 }382 Status error;383 if (InvokeShouldStopHereCallback(eFrameCompareYounger, error)) {384 SetPlanComplete(true);385 return true;386 }387 // If we didn't want to stop at this msgSend, there might be another so388 // we should just continue on with the step out and see if our breakpoint389 // triggers again.390 m_objc_step_through_sp.reset();391 for (BreakpointSP bkpt_sp : m_msgSend_bkpts) {392 bkpt_sp->SetEnabled(true);393 }394 return false;395 }396 397 // If we hit an msgSend breakpoint, then we should queue the step through398 // plan:399 400 if (m_at_msg_send) {401 LanguageRuntime *objc_runtime 402 = GetThread().GetProcess()->GetLanguageRuntime(eLanguageTypeObjC);403 // There's no way we could have gotten here without an ObjC language 404 // runtime.405 assert(objc_runtime);406 m_objc_step_through_sp =407 objc_runtime->GetStepThroughTrampolinePlan(GetThread(), false);408 // If we failed to find the target for this dispatch, just keep going and409 // let the step out complete.410 if (!m_objc_step_through_sp) {411 LLDB_LOG(log, "Couldn't find target for message dispatch, continuing.");412 return false;413 }414 // Otherwise push the step through plan and continue.415 GetThread().QueueThreadPlan(m_objc_step_through_sp, false);416 for (BreakpointSP bkpt_sp : m_msgSend_bkpts) {417 bkpt_sp->SetEnabled(false);418 }419 return false;420 }421 return true; 422}423 424bool AppleThreadPlanStepThroughDirectDispatch::MischiefManaged() {425 if (IsPlanComplete())426 return true;427 return ThreadPlanStepOut::MischiefManaged();428}429