LLDB  mainline
AppleThreadPlanStepThroughObjCTrampoline.cpp
Go to the documentation of this file.
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 
10 
15 #include "lldb/Target/ABI.h"
17 #include "lldb/Target/Process.h"
18 #include "lldb/Target/Thread.h"
21 #include "lldb/Utility/LLDBLog.h"
22 #include "lldb/Utility/Log.h"
23 
25 
26 #include <memory>
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 
31 // ThreadPlanStepThroughObjCTrampoline constructor
32 AppleThreadPlanStepThroughObjCTrampoline::
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,
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
48 
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.
54 }
55 
57  if (!m_func_sp) {
58  DiagnosticManager diagnostics;
59  m_args_addr =
61 
63  return false;
64  }
67  ExecutionContext exc_ctx;
69  options.SetUnwindOnError(true);
70  options.SetIgnoreBreakpoints(true);
71  options.SetStopOthers(false);
74  exc_ctx, m_args_addr, options, diagnostics);
75  m_func_sp->SetOkayToDiscard(true);
77  }
78  return true;
79 }
80 
84  static_cast<AppleThreadPlanStepThroughObjCTrampoline *>(void_myself);
85  return myself->InitializeFunctionCaller();
86 }
87 
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,
97  }
98 }
99 
101  return true;
102 }
103 
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 
113  return eStateRunning;
114 }
115 
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(LLDBLog::Step);
134 
135  if (!m_run_to_sp) {
136  Value target_addr_value;
137  ExecutionContext exc_ctx;
140  target_addr_value);
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%" PRIx64
157  ", 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;
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);
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%" 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  GetThread(), target_so_addr, false);
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 in
213 // your MischiefManaged derived class.
215  return IsPlanComplete();
216 }
217 
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 
243  Thread &thread, AppleObjCTrampolineHandler &handler,
244  llvm::StringRef dispatch_func_name)
245  : ThreadPlanStepOut(thread, nullptr, true /* first instruction */, false,
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(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 right
268  // order.
269 
272  else
274  // We only care about step in. Our parent plan will figure out what to
275  // do when we've stepped out again.
277 }
278 
281  for (BreakpointSP bkpt_sp : m_msgSend_bkpts) {
282  GetTarget().RemoveBreakpointByID(bkpt_sp->GetID());
283  }
284 }
285 
287  Stream *s, lldb::DescriptionLevel level) {
288  switch (level) {
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 
308 bool
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 we
335  // should just stop and return control to the user.
336  if (site_sp->GetNumberOfOwners() > 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 
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 
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(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;
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(eLanguageTypeObjC);
403  // There's no way we could have gotten here without an ObjC language
404  // runtime.
405  assert(objc_runtime);
407  objc_runtime->GetStepThroughTrampolinePlan(GetThread(), 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.
416  for (BreakpointSP bkpt_sp : m_msgSend_bkpts) {
417  bkpt_sp->SetEnabled(false);
418  }
419  return false;
420  }
421  return true;
422 }
423 
425  if (IsPlanComplete())
426  return true;
428 }
lldb_private::ThreadPlanShouldStopHere::eStepOutAvoidNoDebug
@ eStepOutAvoidNoDebug
Definition: ThreadPlanShouldStopHere.h:62
lldb_private::AppleThreadPlanStepThroughDirectDispatch::m_at_msg_send
bool m_at_msg_send
Breakpoints on the objc dispatch functions.
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:116
lldb_private::AppleThreadPlanStepThroughDirectDispatch::m_objc_step_through_sp
lldb::ThreadPlanSP m_objc_step_through_sp
Which dispatch function we're stepping through.
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:111
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::ThreadPlan::GetThread
Thread & GetThread()
Returns the Thread that is using this thread plan.
Definition: ThreadPlan.cpp:42
lldb_private::Event
Definition: Event.h:182
lldb_private::ThreadPlan::IsPlanComplete
bool IsPlanComplete()
Definition: ThreadPlan.cpp:61
FunctionCaller.h
lldb_private::AppleObjCTrampolineHandler::AddrIsMsgForward
bool AddrIsMsgForward(lldb::addr_t addr) const
Definition: AppleObjCTrampolineHandler.h:33
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::DoPlanExplainsStop
bool DoPlanExplainsStop(Event *event_ptr) override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:104
lldb_private::ObjCLanguageRuntime
Definition: ObjCLanguageRuntime.h:35
lldb_private::Value
Definition: Value.h:38
ThreadPlanStepOut.h
lldb_private::AppleThreadPlanStepThroughDirectDispatch::DoPlanExplainsStop
bool DoPlanExplainsStop(Event *event_ptr) override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:309
lldb_private::ObjCLanguageRuntime::Get
static ObjCLanguageRuntime * Get(Process &process)
Definition: ObjCLanguageRuntime.h:214
lldb_private::ValueList::GetValueAtIndex
Value * GetValueAtIndex(size_t idx)
Definition: Value.cpp:669
lldb_private::Thread::QueueThreadPlanForStepOutNoShouldStop
virtual lldb::ThreadPlanSP QueueThreadPlanForStepOutNoShouldStop(bool abort_other_plans, SymbolContext *addr_context, bool first_insn, bool stop_other_threads, Vote report_stop_vote, Vote report_run_vote, uint32_t frame_idx, Status &status, bool continue_to_next_branch=false)
Queue the plan used to step out of the function at the current PC of a thread.
Definition: Thread.cpp:1338
lldb_private::AppleThreadPlanStepThroughDirectDispatch::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level) override
Print a description of this thread to the stream s.
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:286
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:344
lldb_private::ThreadPlanStepOut
Definition: ThreadPlanStepOut.h:18
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged
bool MischiefManaged() override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:214
lldb_private::Flags::Clear
ValueType Clear(ValueType mask=~static_cast< ValueType >(0))
Clear one or more flags.
Definition: Flags.h:61
lldb_private::LanguageRuntime::GetStepThroughTrampolinePlan
virtual lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread, bool stop_others)=0
lldb_private::EvaluateExpressionOptions
Definition: Target.h:277
lldb::StopReason
StopReason
Thread stop reasons.
Definition: lldb-enumerations.h:240
lldb_private::ValueList
Definition: Value.h:157
lldb_private::eVoteNoOpinion
@ eVoteNoOpinion
Definition: lldb-private-enumerations.h:59
lldb_private::Stream
Definition: Stream.h:28
lldb_private::Target::CreateBreakpoint
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpec &file, uint32_t line_no, uint32_t column, lldb::addr_t offset, LazyBool check_inlines, LazyBool skip_prologue, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:353
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::m_func_sp
lldb::ThreadPlanSP m_func_sp
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:67
lldb_private::ThreadPlanStepOut::MischiefManaged
bool MischiefManaged() override
Definition: ThreadPlanStepOut.cpp:418
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::m_impl_function
FunctionCaller * m_impl_function
The plan that runs to the target.
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:71
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::~AppleThreadPlanStepThroughObjCTrampoline
~AppleThreadPlanStepThroughObjCTrampoline() override
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::ValidatePlan
bool ValidatePlan(Stream *error) override
Returns whether this plan could be successfully created.
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:100
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::InitializeFunctionCaller
bool InitializeFunctionCaller()
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:56
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level) override
Print a description of this thread to the stream s.
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:88
ABI.h
lldb_private::ThreadPlanStepOut::ShouldStop
bool ShouldStop(Event *event_ptr) override
Definition: ThreadPlanStepOut.cpp:337
Process.h
lldb_private::AppleThreadPlanStepThroughDirectDispatch::~AppleThreadPlanStepThroughDirectDispatch
~AppleThreadPlanStepThroughDirectDispatch() override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:280
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::m_args_addr
lldb::addr_t m_args_addr
The handler itself.
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:61
lldb_private::FunctionCaller::DeallocateFunctionResults
void DeallocateFunctionResults(ExecutionContext &exe_ctx, lldb::addr_t args_addr)
Deallocate the arguments structure.
Definition: FunctionCaller.cpp:327
lldb_private::Value::GetScalar
const Scalar & GetScalar() const
Definition: Value.h:112
lldb_private::Thread::GetProcess
lldb::ProcessSP GetProcess() const
Definition: Thread.h:153
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::Status::Success
bool Success() const
Test for success condition.
Definition: Status.cpp:287
lldb_private::ThreadProperties::GetStepInAvoidsNoDebug
bool GetStepInAvoidsNoDebug() const
Definition: Thread.cpp:132
lldb_private::ThreadPlan::GetTarget
Target & GetTarget()
Definition: ThreadPlan.cpp:38
lldb_private::ThreadPlan
Definition: ThreadPlan.h:287
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::GetPlanRunState
lldb::StateType GetPlanRunState() override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:112
lldb_private::Scalar::ULongLong
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:334
Log.h
lldb_private::ThreadPlanShouldStopHere::eStepInAvoidNoDebug
@ eStepInAvoidNoDebug
Definition: ThreadPlanShouldStopHere.h:61
lldb_private::Thread
Definition: Thread.h:61
lldb::eStopReasonNone
@ eStopReasonNone
Definition: lldb-enumerations.h:242
AppleThreadPlanStepThroughObjCTrampoline.h
lldb_private::Status::Fail
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
lldb_private::Process::AddPreResumeAction
void AddPreResumeAction(PreResumeActionCallback callback, void *baton)
Definition: Process.cpp:5575
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::m_isa_addr
lldb::addr_t m_isa_addr
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:64
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::WillStop
bool WillStop() override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:218
lldb_private::AppleObjCTrampolineHandler::ForEachDispatchFunction
void ForEachDispatchFunction(std::function< void(lldb::addr_t, const DispatchFunction &)>)
Definition: AppleObjCTrampolineHandler.cpp:784
lldb_private::LanguageRuntime
Definition: LanguageRuntime.h:60
ThreadPlanRunToAddress.h
lldb_private::AppleThreadPlanStepThroughObjCTrampoline
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:23
lldb::eFrameCompareYounger
@ eFrameCompareYounger
Definition: lldb-enumerations.h:883
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::Address::SetOpcodeLoadAddress
bool SetOpcodeLoadAddress(lldb::addr_t load_addr, Target *target, AddressClass addr_class=AddressClass::eInvalid, bool allow_section_end=false)
Definition: Address.cpp:379
lldb_private::EvaluateExpressionOptions::SetUnwindOnError
void SetUnwindOnError(bool unwind=false)
Definition: Target.h:324
Thread.h
lldb_private::AppleObjCTrampolineHandler
Definition: AppleObjCTrampolineHandler.h:21
lldb_private::ThreadPlanShouldStopHere::GetFlags
lldb_private::Flags & GetFlags()
Definition: ThreadPlanShouldStopHere.h:104
lldb_private::LLDBLog::Step
@ Step
lldb_private::AppleThreadPlanStepThroughDirectDispatch::m_dispatch_func_name
std::string m_dispatch_func_name
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:109
lldb_private::FunctionCaller::FetchFunctionResults
bool FetchFunctionResults(ExecutionContext &exe_ctx, lldb::addr_t args_addr, Value &ret_value)
Get the result of the function from its struct.
Definition: FunctionCaller.cpp:288
lldb_private::UserID::GetID
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47
lldb_private::Thread::CalculateExecutionContext
void CalculateExecutionContext(ExecutionContext &exe_ctx) override
Reconstruct the object's execution context into sc.
Definition: Thread.cpp:1419
UtilityFunction.h
lldb_private::ThreadPlan::PushPlan
void PushPlan(lldb::ThreadPlanSP &thread_plan_sp)
Definition: ThreadPlan.h:502
lldb_private::AppleObjCTrampolineHandler::GetLookupImplementationFunctionCaller
FunctionCaller * GetLookupImplementationFunctionCaller()
Definition: AppleObjCTrampolineHandler.cpp:1178
lldb::eLanguageTypeObjC
@ eLanguageTypeObjC
Objective-C.
Definition: lldb-enumerations.h:454
lldb_private::EvaluateExpressionOptions::SetIgnoreBreakpoints
void SetIgnoreBreakpoints(bool ignore=false)
Definition: Target.h:328
lldb_private::ObjCLanguageRuntime::AddToMethodCache
void AddToMethodCache(lldb::addr_t class_addr, lldb::addr_t sel, lldb::addr_t impl_addr)
Definition: ObjCLanguageRuntime.cpp:64
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::m_run_to_sp
lldb::ThreadPlanSP m_run_to_sp
This is the function call plan.
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:70
lldb_private::ThreadPlan::SetPlanComplete
void SetPlanComplete(bool success=true)
Definition: ThreadPlan.cpp:66
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::m_sel_str
std::string m_sel_str
If this is not LLDB_INVALID_ADDRESS then it is the address we wrote the selector string to.
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:78
lldb_private::Status
Definition: Status.h:44
lldb_private::AppleThreadPlanStepThroughDirectDispatch::ShouldStop
bool ShouldStop(Event *event_ptr) override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:359
uint32_t
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
lldb_private::Address
Definition: Address.h:59
lldb_private::Thread::QueueThreadPlan
Status QueueThreadPlan(lldb::ThreadPlanSP &plan_sp, bool abort_other_plans)
Queues a generic thread plan.
Definition: Thread.cpp:1171
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::m_sel_str_addr
lldb::addr_t m_sel_str_addr
This is a pointer to a impl function that is owned by the client that pushes this plan.
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:74
lldb_private::ThreadPlanStepOut::DoWillResume
bool DoWillResume(lldb::StateType resume_state, bool current_plan) override
Definition: ThreadPlanStepOut.cpp:392
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::PreResumeInitializeFunctionCaller
static bool PreResumeInitializeFunctionCaller(void *myself)
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:82
lldb_private::DiagnosticManager
Definition: DiagnosticManager.h:93
ObjCLanguageRuntime.h
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::ShouldStop
bool ShouldStop(Event *event_ptr) override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:116
lldb_private::AppleThreadPlanStepThroughDirectDispatch::DoWillResume
bool DoWillResume(lldb::StateType resume_state, bool current_plan) override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:353
lldb::eStopReasonBreakpoint
@ eStopReasonBreakpoint
Definition: lldb-enumerations.h:244
lldb_private::Target::RemoveBreakpointByID
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:953
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:337
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
DiagnosticManager.h
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::ThreadPlanShouldStopHere::InvokeShouldStopHereCallback
bool InvokeShouldStopHereCallback(lldb::FrameComparison operation, Status &status)
Definition: ThreadPlanShouldStopHere.cpp:39
lldb_private::ThreadPlanStepOut::DoPlanExplainsStop
bool DoPlanExplainsStop(Event *event_ptr) override
Definition: ThreadPlanStepOut.cpp:269
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::m_sel_addr
lldb::addr_t m_sel_addr
isa_addr and sel_addr are the keys we will use to cache the implementation.
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:66
lldb_private::FunctionCaller::GetThreadPlanToCallFunction
lldb::ThreadPlanSP GetThreadPlanToCallFunction(ExecutionContext &exe_ctx, lldb::addr_t args_addr, const EvaluateExpressionOptions &options, DiagnosticManager &diagnostic_manager)
Get a thread plan to run the function this FunctionCaller was created with.
Definition: FunctionCaller.cpp:255
lldb_private::Flags::Set
ValueType Set(ValueType mask)
Set one or more flags by logical OR'ing mask with the current flags.
Definition: Flags.h:73
lldb_private::AppleObjCTrampolineHandler::SetupDispatchFunction
lldb::addr_t SetupDispatchFunction(Thread &thread, ValueList &dispatch_values)
Definition: AppleObjCTrampolineHandler.cpp:700
lldb_private::AppleThreadPlanStepThroughDirectDispatch::m_msgSend_bkpts
std::vector< lldb::BreakpointSP > m_msgSend_bkpts
When we hit an objc_msgSend, we'll use this plan to get to its target.
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:114
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:74
lldb_private::Log
Definition: Log.h:115
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb_private::AppleThreadPlanStepThroughDirectDispatch::AppleThreadPlanStepThroughDirectDispatch
AppleThreadPlanStepThroughDirectDispatch(Thread &thread, AppleObjCTrampolineHandler &handler, llvm::StringRef dispatch_func_name)
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:242
lldb_private::EvaluateExpressionOptions::SetStopOthers
void SetStopOthers(bool stop_others=true)
Definition: Target.h:361
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::DidPush
void DidPush() override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:49
lldb_private::Thread::GetStackFrameAtIndex
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:399
lldb_private::ThreadPlan::GetPrivateStopInfo
lldb::StopInfoSP GetPrivateStopInfo()
Definition: ThreadPlan.h:517
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
lldb_private::ThreadPlan::m_process
Process & m_process
Definition: ThreadPlan.h:530
lldb_private::AppleThreadPlanStepThroughDirectDispatch::MischiefManaged
bool MischiefManaged() override
Definition: AppleThreadPlanStepThroughObjCTrampoline.cpp:424
lldb
Definition: SBAddress.h:15
lldb::eStateRunning
@ eStateRunning
Process or thread is running and can't be examined.
Definition: lldb-enumerations.h:86
LLDBLog.h
lldb_private::ExecutionContext::GetTargetPtr
Target * GetTargetPtr() const
Returns a pointer to the target object.
Definition: ExecutionContext.cpp:198
ExecutionContext.h
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::m_input_values
ValueList m_input_values
Stores the address for our step through function result structure.
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:63
lldb::eDescriptionLevelBrief
@ eDescriptionLevelBrief
Definition: lldb-enumerations.h:209
lldb_private::AppleThreadPlanStepThroughObjCTrampoline::m_trampoline_handler
AppleObjCTrampolineHandler & m_trampoline_handler
Definition: AppleThreadPlanStepThroughObjCTrampoline.h:60
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:208
AppleObjCTrampolineHandler.h