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-exception
6//
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 constructor
32AppleThreadPlanStepThroughObjCTrampoline::
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// Destructor
46AppleThreadPlanStepThroughObjCTrampoline::
47 ~AppleThreadPlanStepThroughObjCTrampoline() = default;
48
49void AppleThreadPlanStepThroughObjCTrampoline::DidPush() {
50 // Setting up the memory space for the called function text might require
51 // allocations, i.e. a nested function call. This needs to be done as a
52 // PreResumeAction.
53 m_process.AddPreResumeAction(callback: PreResumeInitializeFunctionCaller, baton: (void *)this);
54}
55
56bool AppleThreadPlanStepThroughObjCTrampoline::InitializeFunctionCaller() {
57 if (!m_func_sp) {
58 DiagnosticManager diagnostics;
59 m_args_addr =
60 m_trampoline_handler.SetupDispatchFunction(thread&: GetThread(), dispatch_values&: 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(exe_ctx&: exc_ctx);
73 m_func_sp = m_impl_function->GetThreadPlanToCallFunction(
74 exe_ctx&: exc_ctx, args_addr: m_args_addr, options, diagnostic_manager&: diagnostics);
75 m_func_sp->SetOkayToDiscard(true);
76 PushPlan(thread_plan_sp&: 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(format: "Step through ObjC trampoline");
92 else {
93 s->Printf(format: "Stepping to implementation of ObjC method - obj: 0x%llx, isa: "
94 "0x%" PRIx64 ", sel: 0x%" PRIx64,
95 m_input_values.GetValueAtIndex(idx: 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 went
107 // wrong (like the implementation for selector function crashed... We're
108 // 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 target
118 // 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 the
132 // implementation function address, and queue up a "run to that address" plan.
133 Log *log = GetLog(mask: LLDBLog::Step);
134
135 if (!m_run_to_sp) {
136 Value target_addr_value;
137 ExecutionContext exc_ctx;
138 GetThread().CalculateExecutionContext(exe_ctx&: exc_ctx);
139 m_impl_function->FetchFunctionResults(exe_ctx&: exc_ctx, args_addr: m_args_addr,
140 ret_value&: target_addr_value);
141 m_impl_function->DeallocateFunctionResults(exe_ctx&: exc_ctx, args_addr: 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(pc: target_addr);
146 }
147 Address target_so_addr;
148 target_so_addr.SetOpcodeLoadAddress(load_addr: target_addr, target: 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(addr: target_addr)) {
155 LLDB_LOGF(log,
156 "Implementation lookup returned msgForward function: 0x%" PRIx64
157 ", stopping.",
158 target_addr);
159
160 SymbolContext sc = GetThread().GetStackFrameAtIndex(idx: 0)->GetSymbolContext(
161 resolve_scope: 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, addr_context: &sc, first_insn, stop_other_threads: false, report_stop_vote: eVoteNoOpinion,
168 report_run_vote: 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(process&: *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(ptr: 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(class_addr: m_isa_addr, sel_str: m_sel_str, impl_addr: 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(class_addr: m_isa_addr, sel: m_sel_addr, impl_addr: target_addr);
194 LLDB_LOGF(log,
195 "Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64
196 "} = 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 args&: GetThread(), args&: target_so_addr, args: false);
202 PushPlan(thread_plan_sp&: m_run_to_sp);
203 return false;
204 } else if (GetThread().IsThreadPlanDone(plan: 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 in
213// 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 seldom
221// overridden methods. For instance
222// [object respondsToSelector:];
223// will get compiled to:
224// objc_opt_respondsToSelector(object);
225// This checks whether the selector has been overridden, directly calling the
226// 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 stop
230// at objc_msgSend, we can step through to the target of the send, and see if
231// 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 dispatch
235// functions might dispatch more than one message at a time (e.g. alloc followed
236// 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 the
239// 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 this
249 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 AppleObjCTrampolineHandler
259 ::DispatchFunction &dispatch) {
260 m_msgSend_bkpts.push_back(x: GetTarget().CreateBreakpoint(load_addr: addr,
261 internal: true /* internal */,
262 request_hardware: 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 right
268 // order.
269
270 if (GetThread().GetStepInAvoidsNoDebug())
271 GetFlags().Set(ThreadPlanShouldStopHere::eStepInAvoidNoDebug);
272 else
273 GetFlags().Clear(mask: ThreadPlanShouldStopHere::eStepInAvoidNoDebug);
274 // We only care about step in. Our parent plan will figure out what to
275 // do when we've stepped out again.
276 GetFlags().Clear(mask: ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
277}
278
279AppleThreadPlanStepThroughDirectDispatch::
280 ~AppleThreadPlanStepThroughDirectDispatch() {
281 for (BreakpointSP bkpt_sp : m_msgSend_bkpts) {
282 GetTarget().RemoveBreakpointByID(break_id: 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(cstr: "Step through ObjC direct dispatch function.");
291 break;
292 default:
293 s->Printf(format: "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(cstr: ", ");
299 }
300 first = false;
301 s->Printf(format: "%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(site_id: 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(bp_id: break_sp->GetID())) {
334 // If we aren't the only one with a breakpoint on this site, then we
335 // 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 were
348 // done, we'll get called to figure out what to do in ShouldStop...
349 return false;
350}
351
352bool AppleThreadPlanStepThroughDirectDispatch
353 ::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 method
361 // 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(mask: 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 the
377 // step over plan get us out of here... We don't need to do anything about
378 // 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(operation: eFrameCompareYounger, status&: error)) {
384 SetPlanComplete(true);
385 return true;
386 }
387 // If we didn't want to stop at this msgSend, there might be another so
388 // we should just continue on with the step out and see if our breakpoint
389 // 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 through
398 // plan:
399
400 if (m_at_msg_send) {
401 LanguageRuntime *objc_runtime
402 = GetThread().GetProcess()->GetLanguageRuntime(language: 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(thread&: GetThread(), stop_others: false);
408 // If we failed to find the target for this dispatch, just keep going and
409 // 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(plan_sp&: m_objc_step_through_sp, abort_other_plans: 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

source code of lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp