1 //===-- AppleThreadPlanStepThroughObjCTrampoline.cpp --------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // C Includes
11 // C++ Includes
12 // Other libraries and framework includes
13 // Project includes
14 #include "AppleThreadPlanStepThroughObjCTrampoline.h"
15 #include "AppleObjCTrampolineHandler.h"
16 #include "lldb/Target/Process.h"
17 #include "lldb/Target/Thread.h"
18 #include "lldb/Expression/ClangExpression.h"
19 #include "lldb/Expression/ClangFunction.h"
20 #include "lldb/Target/ExecutionContext.h"
21 #include "lldb/Target/ObjCLanguageRuntime.h"
22 #include "lldb/Target/ThreadPlanRunToAddress.h"
23 #include "lldb/Target/ThreadPlanStepOut.h"
24 #include "lldb/Core/Log.h"
25
26
27 using namespace lldb;
28 using namespace lldb_private;
29
30 //----------------------------------------------------------------------
31 // ThreadPlanStepThroughObjCTrampoline constructor
32 //----------------------------------------------------------------------
AppleThreadPlanStepThroughObjCTrampoline(Thread & thread,AppleObjCTrampolineHandler * trampoline_handler,ValueList & input_values,lldb::addr_t isa_addr,lldb::addr_t sel_addr,bool stop_others)33 AppleThreadPlanStepThroughObjCTrampoline::AppleThreadPlanStepThroughObjCTrampoline
34 (
35 Thread &thread,
36 AppleObjCTrampolineHandler *trampoline_handler,
37 ValueList &input_values,
38 lldb::addr_t isa_addr,
39 lldb::addr_t sel_addr,
40 bool stop_others
41 ) :
42 ThreadPlan (ThreadPlan::eKindGeneric,
43 "MacOSX Step through ObjC Trampoline",
44 thread,
45 eVoteNoOpinion,
46 eVoteNoOpinion),
47 m_trampoline_handler (trampoline_handler),
48 m_args_addr (LLDB_INVALID_ADDRESS),
49 m_input_values (input_values),
50 m_isa_addr(isa_addr),
51 m_sel_addr(sel_addr),
52 m_impl_function (NULL),
53 m_stop_others (stop_others)
54 {
55
56 }
57
58 //----------------------------------------------------------------------
59 // Destructor
60 //----------------------------------------------------------------------
~AppleThreadPlanStepThroughObjCTrampoline()61 AppleThreadPlanStepThroughObjCTrampoline::~AppleThreadPlanStepThroughObjCTrampoline()
62 {
63 }
64
65 void
DidPush()66 AppleThreadPlanStepThroughObjCTrampoline::DidPush ()
67 {
68 // Setting up the memory space for the called function text might require allocations,
69 // i.e. a nested function call. This needs to be done as a PreResumeAction.
70 m_thread.GetProcess()->AddPreResumeAction (PreResumeInitializeClangFunction, (void *) this);
71 }
72
73 bool
InitializeClangFunction()74 AppleThreadPlanStepThroughObjCTrampoline::InitializeClangFunction ()
75 {
76 if (!m_func_sp)
77 {
78 StreamString errors;
79 m_args_addr = m_trampoline_handler->SetupDispatchFunction(m_thread, m_input_values);
80
81 if (m_args_addr == LLDB_INVALID_ADDRESS)
82 {
83 return false;
84 }
85 m_impl_function = m_trampoline_handler->GetLookupImplementationWrapperFunction();
86 ExecutionContext exc_ctx;
87 const bool unwind_on_error = true;
88 const bool ignore_breakpoints = true;
89 m_thread.CalculateExecutionContext(exc_ctx);
90 m_func_sp.reset(m_impl_function->GetThreadPlanToCallFunction (exc_ctx,
91 m_args_addr,
92 errors,
93 m_stop_others,
94 unwind_on_error,
95 ignore_breakpoints));
96 m_func_sp->SetOkayToDiscard(true);
97 m_thread.QueueThreadPlan (m_func_sp, false);
98 }
99 return true;
100 }
101
102 bool
PreResumeInitializeClangFunction(void * void_myself)103 AppleThreadPlanStepThroughObjCTrampoline::PreResumeInitializeClangFunction(void *void_myself)
104 {
105 AppleThreadPlanStepThroughObjCTrampoline *myself = static_cast<AppleThreadPlanStepThroughObjCTrampoline *>(void_myself);
106 return myself->InitializeClangFunction();
107 }
108
109 void
GetDescription(Stream * s,lldb::DescriptionLevel level)110 AppleThreadPlanStepThroughObjCTrampoline::GetDescription (Stream *s,
111 lldb::DescriptionLevel level)
112 {
113 if (level == lldb::eDescriptionLevelBrief)
114 s->Printf("Step through ObjC trampoline");
115 else
116 {
117 s->Printf ("Stepping to implementation of ObjC method - obj: 0x%llx, isa: 0x%" PRIx64 ", sel: 0x%" PRIx64,
118 m_input_values.GetValueAtIndex(0)->GetScalar().ULongLong(), m_isa_addr, m_sel_addr);
119 }
120 }
121
122 bool
ValidatePlan(Stream * error)123 AppleThreadPlanStepThroughObjCTrampoline::ValidatePlan (Stream *error)
124 {
125 return true;
126 }
127
128 bool
DoPlanExplainsStop(Event * event_ptr)129 AppleThreadPlanStepThroughObjCTrampoline::DoPlanExplainsStop (Event *event_ptr)
130 {
131 // If we get asked to explain the stop it will be because something went
132 // wrong (like the implementation for selector function crashed... We're going
133 // to figure out what to do about that, so we do explain the stop.
134 return true;
135 }
136
137 lldb::StateType
GetPlanRunState()138 AppleThreadPlanStepThroughObjCTrampoline::GetPlanRunState ()
139 {
140 return eStateRunning;
141 }
142
143 bool
ShouldStop(Event * event_ptr)144 AppleThreadPlanStepThroughObjCTrampoline::ShouldStop (Event *event_ptr)
145 {
146 // First stage: we are still handling the "call a function to get the target of the dispatch"
147 if (m_func_sp)
148 {
149 if (!m_func_sp->IsPlanComplete())
150 {
151 return false;
152 }
153 else
154 {
155 if (!m_func_sp->PlanSucceeded())
156 {
157 SetPlanComplete(false);
158 return true;
159 }
160 m_func_sp.reset();
161 }
162 }
163
164 // Second stage, if all went well with the function calling, then fetch the target address, and
165 // queue up a "run to that address" plan.
166 if (!m_run_to_sp)
167 {
168 Value target_addr_value;
169 ExecutionContext exc_ctx;
170 m_thread.CalculateExecutionContext(exc_ctx);
171 m_impl_function->FetchFunctionResults (exc_ctx, m_args_addr, target_addr_value);
172 m_impl_function->DeallocateFunctionResults(exc_ctx, m_args_addr);
173 lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong();
174 Address target_so_addr;
175 target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr());
176 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
177 if (target_addr == 0)
178 {
179 if (log)
180 log->Printf("Got target implementation of 0x0, stopping.");
181 SetPlanComplete();
182 return true;
183 }
184 if (m_trampoline_handler->AddrIsMsgForward(target_addr))
185 {
186 if (log)
187 log->Printf ("Implementation lookup returned msgForward function: 0x%" PRIx64 ", stopping.", target_addr);
188
189 SymbolContext sc = m_thread.GetStackFrameAtIndex(0)->GetSymbolContext(eSymbolContextEverything);
190 m_run_to_sp.reset(new ThreadPlanStepOut (m_thread,
191 &sc,
192 true,
193 m_stop_others,
194 eVoteNoOpinion,
195 eVoteNoOpinion,
196 0));
197 m_thread.QueueThreadPlan(m_run_to_sp, false);
198 m_run_to_sp->SetPrivate(true);
199 return false;
200 }
201
202 if (log)
203 log->Printf("Running to ObjC method implementation: 0x%" PRIx64, target_addr);
204
205 ObjCLanguageRuntime *objc_runtime = GetThread().GetProcess()->GetObjCLanguageRuntime();
206 assert (objc_runtime != NULL);
207 objc_runtime->AddToMethodCache (m_isa_addr, m_sel_addr, target_addr);
208 if (log)
209 log->Printf("Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64 "} = addr=0x%" PRIx64 " to cache.", m_isa_addr, m_sel_addr, target_addr);
210
211 // Extract the target address from the value:
212
213 m_run_to_sp.reset(new ThreadPlanRunToAddress(m_thread, target_so_addr, m_stop_others));
214 m_thread.QueueThreadPlan(m_run_to_sp, false);
215 m_run_to_sp->SetPrivate(true);
216 return false;
217 }
218 else if (m_thread.IsThreadPlanDone(m_run_to_sp.get()))
219 {
220 // Third stage, work the run to target plan.
221 SetPlanComplete();
222 return true;
223 }
224 return false;
225 }
226
227 // The base class MischiefManaged does some cleanup - so you have to call it
228 // in your MischiefManaged derived class.
229 bool
MischiefManaged()230 AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged ()
231 {
232 if (IsPlanComplete())
233 return true;
234 else
235 return false;
236 }
237
238 bool
WillStop()239 AppleThreadPlanStepThroughObjCTrampoline::WillStop()
240 {
241 return true;
242 }
243