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/ExecutionContext.h"
16 #include "lldb/Target/Process.h"
17 #include "lldb/Target/Thread.h"
18 #include "lldb/Target/ThreadPlanRunToAddress.h"
19 #include "lldb/Target/ThreadPlanStepOut.h"
20 #include "lldb/Utility/Log.h"
21
22 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
23
24 #include <memory>
25
26 using namespace lldb;
27 using namespace lldb_private;
28
29 // ThreadPlanStepThroughObjCTrampoline constructor
30 AppleThreadPlanStepThroughObjCTrampoline::
AppleThreadPlanStepThroughObjCTrampoline(Thread & thread,AppleObjCTrampolineHandler * trampoline_handler,ValueList & input_values,lldb::addr_t isa_addr,lldb::addr_t sel_addr,bool stop_others)31 AppleThreadPlanStepThroughObjCTrampoline(
32 Thread &thread, AppleObjCTrampolineHandler *trampoline_handler,
33 ValueList &input_values, lldb::addr_t isa_addr, lldb::addr_t sel_addr,
34 bool stop_others)
35 : ThreadPlan(ThreadPlan::eKindGeneric,
36 "MacOSX Step through ObjC Trampoline", thread, eVoteNoOpinion,
37 eVoteNoOpinion),
38 m_trampoline_handler(trampoline_handler),
39 m_args_addr(LLDB_INVALID_ADDRESS), m_input_values(input_values),
40 m_isa_addr(isa_addr), m_sel_addr(sel_addr), m_impl_function(nullptr),
41 m_stop_others(stop_others) {}
42
43 // Destructor
44 AppleThreadPlanStepThroughObjCTrampoline::
~AppleThreadPlanStepThroughObjCTrampoline()45 ~AppleThreadPlanStepThroughObjCTrampoline() {}
46
DidPush()47 void AppleThreadPlanStepThroughObjCTrampoline::DidPush() {
48 // Setting up the memory space for the called function text might require
49 // allocations, i.e. a nested function call. This needs to be done as a
50 // PreResumeAction.
51 m_thread.GetProcess()->AddPreResumeAction(PreResumeInitializeFunctionCaller,
52 (void *)this);
53 }
54
InitializeFunctionCaller()55 bool AppleThreadPlanStepThroughObjCTrampoline::InitializeFunctionCaller() {
56 if (!m_func_sp) {
57 DiagnosticManager diagnostics;
58 m_args_addr =
59 m_trampoline_handler->SetupDispatchFunction(m_thread, m_input_values);
60
61 if (m_args_addr == LLDB_INVALID_ADDRESS) {
62 return false;
63 }
64 m_impl_function =
65 m_trampoline_handler->GetLookupImplementationFunctionCaller();
66 ExecutionContext exc_ctx;
67 EvaluateExpressionOptions options;
68 options.SetUnwindOnError(true);
69 options.SetIgnoreBreakpoints(true);
70 options.SetStopOthers(m_stop_others);
71 m_thread.CalculateExecutionContext(exc_ctx);
72 m_func_sp = m_impl_function->GetThreadPlanToCallFunction(
73 exc_ctx, m_args_addr, options, diagnostics);
74 m_func_sp->SetOkayToDiscard(true);
75 m_thread.QueueThreadPlan(m_func_sp, false);
76 }
77 return true;
78 }
79
80 bool AppleThreadPlanStepThroughObjCTrampoline::
PreResumeInitializeFunctionCaller(void * void_myself)81 PreResumeInitializeFunctionCaller(void *void_myself) {
82 AppleThreadPlanStepThroughObjCTrampoline *myself =
83 static_cast<AppleThreadPlanStepThroughObjCTrampoline *>(void_myself);
84 return myself->InitializeFunctionCaller();
85 }
86
GetDescription(Stream * s,lldb::DescriptionLevel level)87 void AppleThreadPlanStepThroughObjCTrampoline::GetDescription(
88 Stream *s, lldb::DescriptionLevel level) {
89 if (level == lldb::eDescriptionLevelBrief)
90 s->Printf("Step through ObjC trampoline");
91 else {
92 s->Printf("Stepping to implementation of ObjC method - obj: 0x%llx, isa: "
93 "0x%" PRIx64 ", sel: 0x%" PRIx64,
94 m_input_values.GetValueAtIndex(0)->GetScalar().ULongLong(),
95 m_isa_addr, m_sel_addr);
96 }
97 }
98
ValidatePlan(Stream * error)99 bool AppleThreadPlanStepThroughObjCTrampoline::ValidatePlan(Stream *error) {
100 return true;
101 }
102
DoPlanExplainsStop(Event * event_ptr)103 bool AppleThreadPlanStepThroughObjCTrampoline::DoPlanExplainsStop(
104 Event *event_ptr) {
105 // If we get asked to explain the stop it will be because something went
106 // wrong (like the implementation for selector function crashed... We're
107 // going to figure out what to do about that, so we do explain the stop.
108 return true;
109 }
110
GetPlanRunState()111 lldb::StateType AppleThreadPlanStepThroughObjCTrampoline::GetPlanRunState() {
112 return eStateRunning;
113 }
114
ShouldStop(Event * event_ptr)115 bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) {
116 // First stage: we are still handling the "call a function to get the target
117 // of the dispatch"
118 if (m_func_sp) {
119 if (!m_func_sp->IsPlanComplete()) {
120 return false;
121 } else {
122 if (!m_func_sp->PlanSucceeded()) {
123 SetPlanComplete(false);
124 return true;
125 }
126 m_func_sp.reset();
127 }
128 }
129
130 // Second stage, if all went well with the function calling, then fetch the
131 // target address, and queue up a "run to that address" plan.
132 if (!m_run_to_sp) {
133 Value target_addr_value;
134 ExecutionContext exc_ctx;
135 m_thread.CalculateExecutionContext(exc_ctx);
136 m_impl_function->FetchFunctionResults(exc_ctx, m_args_addr,
137 target_addr_value);
138 m_impl_function->DeallocateFunctionResults(exc_ctx, m_args_addr);
139 lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong();
140 Address target_so_addr;
141 target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr());
142 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
143 if (target_addr == 0) {
144 LLDB_LOGF(log, "Got target implementation of 0x0, stopping.");
145 SetPlanComplete();
146 return true;
147 }
148 if (m_trampoline_handler->AddrIsMsgForward(target_addr)) {
149 LLDB_LOGF(log,
150 "Implementation lookup returned msgForward function: 0x%" PRIx64
151 ", stopping.",
152 target_addr);
153
154 SymbolContext sc = m_thread.GetStackFrameAtIndex(0)->GetSymbolContext(
155 eSymbolContextEverything);
156 Status status;
157 const bool abort_other_plans = false;
158 const bool first_insn = true;
159 const uint32_t frame_idx = 0;
160 m_run_to_sp = m_thread.QueueThreadPlanForStepOutNoShouldStop(
161 abort_other_plans, &sc, first_insn, m_stop_others, eVoteNoOpinion,
162 eVoteNoOpinion, frame_idx, status);
163 if (m_run_to_sp && status.Success())
164 m_run_to_sp->SetPrivate(true);
165 return false;
166 }
167
168 LLDB_LOGF(log, "Running to ObjC method implementation: 0x%" PRIx64,
169 target_addr);
170
171 ObjCLanguageRuntime *objc_runtime =
172 ObjCLanguageRuntime::Get(*GetThread().GetProcess());
173 assert(objc_runtime != nullptr);
174 objc_runtime->AddToMethodCache(m_isa_addr, m_sel_addr, target_addr);
175 LLDB_LOGF(log,
176 "Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64
177 "} = addr=0x%" PRIx64 " to cache.",
178 m_isa_addr, m_sel_addr, target_addr);
179
180 // Extract the target address from the value:
181
182 m_run_to_sp = std::make_shared<ThreadPlanRunToAddress>(
183 m_thread, target_so_addr, m_stop_others);
184 m_thread.QueueThreadPlan(m_run_to_sp, false);
185 m_run_to_sp->SetPrivate(true);
186 return false;
187 } else if (m_thread.IsThreadPlanDone(m_run_to_sp.get())) {
188 // Third stage, work the run to target plan.
189 SetPlanComplete();
190 return true;
191 }
192 return false;
193 }
194
195 // The base class MischiefManaged does some cleanup - so you have to call it in
196 // your MischiefManaged derived class.
MischiefManaged()197 bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() {
198 return IsPlanComplete();
199 }
200
WillStop()201 bool AppleThreadPlanStepThroughObjCTrampoline::WillStop() { return true; }
202