AppleThreadPlanStepThroughObjCTrampoline.cpp revision 360784 
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
26using namespace lldb;
27using namespace lldb_private;
28
29// ThreadPlanStepThroughObjCTrampoline constructor
30AppleThreadPlanStepThroughObjCTrampoline::
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
44AppleThreadPlanStepThroughObjCTrampoline::
45    ~AppleThreadPlanStepThroughObjCTrampoline() {}
46
47void 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
55bool 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
80bool AppleThreadPlanStepThroughObjCTrampoline::
81    PreResumeInitializeFunctionCaller(void *void_myself) {
82  AppleThreadPlanStepThroughObjCTrampoline *myself =
83      static_cast<AppleThreadPlanStepThroughObjCTrampoline *>(void_myself);
84  return myself->InitializeFunctionCaller();
85}
86
87void 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
99bool AppleThreadPlanStepThroughObjCTrampoline::ValidatePlan(Stream *error) {
100  return true;
101}
102
103bool 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
111lldb::StateType AppleThreadPlanStepThroughObjCTrampoline::GetPlanRunState() {
112  return eStateRunning;
113}
114
115bool 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.
197bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() {
198  return IsPlanComplete();
199}
200
201bool AppleThreadPlanStepThroughObjCTrampoline::WillStop() { return true; }
202