• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- AppleObjCTrampolineHandler.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 "AppleObjCTrampolineHandler.h"
10 #include "AppleThreadPlanStepThroughObjCTrampoline.h"
11 
12 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
13 #include "lldb/Breakpoint/StoppointCallbackContext.h"
14 #include "lldb/Core/Debugger.h"
15 #include "lldb/Core/Module.h"
16 #include "lldb/Core/StreamFile.h"
17 #include "lldb/Core/Value.h"
18 #include "lldb/Expression/DiagnosticManager.h"
19 #include "lldb/Expression/FunctionCaller.h"
20 #include "lldb/Expression/UserExpression.h"
21 #include "lldb/Expression/UtilityFunction.h"
22 #include "lldb/Symbol/Symbol.h"
23 #include "lldb/Target/ABI.h"
24 #include "lldb/Target/ExecutionContext.h"
25 #include "lldb/Target/Process.h"
26 #include "lldb/Target/RegisterContext.h"
27 #include "lldb/Target/Target.h"
28 #include "lldb/Target/Thread.h"
29 #include "lldb/Target/ThreadPlanRunToAddress.h"
30 #include "lldb/Utility/ConstString.h"
31 #include "lldb/Utility/FileSpec.h"
32 #include "lldb/Utility/Log.h"
33 
34 #include "llvm/ADT/STLExtras.h"
35 
36 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
37 
38 #include <memory>
39 
40 using namespace lldb;
41 using namespace lldb_private;
42 
43 const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_name =
44     "__lldb_objc_find_implementation_for_selector";
45 const char *AppleObjCTrampolineHandler::
46     g_lookup_implementation_with_stret_function_code =
47         "                               \n\
48 extern \"C\"                                                                 \n\
49 {                                                                            \n\
50     extern void *class_getMethodImplementation(void *objc_class, void *sel); \n\
51     extern void *class_getMethodImplementation_stret(void *objc_class,       \n\
52                                                      void *sel);             \n\
53     extern void * object_getClass (id object);                               \n\
54     extern void * sel_getUid(char *name);                                    \n\
55     extern int printf(const char *format, ...);                              \n\
56 }                                                                            \n\
57 extern \"C\" void * __lldb_objc_find_implementation_for_selector (           \n\
58                                                     void *object,            \n\
59                                                     void *sel,               \n\
60                                                     int is_stret,            \n\
61                                                     int is_super,            \n\
62                                                     int is_super2,           \n\
63                                                     int is_fixup,            \n\
64                                                     int is_fixed,            \n\
65                                                     int debug)               \n\
66 {                                                                            \n\
67     struct __lldb_imp_return_struct                                          \n\
68     {                                                                        \n\
69         void *class_addr;                                                    \n\
70         void *sel_addr;                                                      \n\
71         void *impl_addr;                                                     \n\
72     };                                                                       \n\
73                                                                              \n\
74     struct __lldb_objc_class {                                               \n\
75         void *isa;                                                           \n\
76         void *super_ptr;                                                     \n\
77     };                                                                       \n\
78     struct __lldb_objc_super {                                               \n\
79         void *receiver;                                                      \n\
80         struct __lldb_objc_class *class_ptr;                                 \n\
81     };                                                                       \n\
82     struct __lldb_msg_ref {                                                  \n\
83         void *dont_know;                                                     \n\
84         void *sel;                                                           \n\
85     };                                                                       \n\
86                                                                              \n\
87     struct __lldb_imp_return_struct return_struct;                           \n\
88                                                                              \n\
89     if (debug)                                                               \n\
90         printf (\"\\n*** Called with obj: 0x%p sel: 0x%p is_stret: %d is_super: %d, \"\n\
91                 \"is_super2: %d, is_fixup: %d, is_fixed: %d\\n\",            \n\
92                  object, sel, is_stret, is_super, is_super2, is_fixup, is_fixed);\n\
93     if (is_super)                                                            \n\
94     {                                                                        \n\
95         if (is_super2)                                                       \n\
96         {                                                                    \n\
97             return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr->super_ptr;\n\
98         }                                                                    \n\
99         else                                                                 \n\
100         {                                                                    \n\
101             return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr;\n\
102         }                                                                    \n\
103     }                                                                        \n\
104     else                                                                     \n\
105     {                                                                        \n\
106         // This code seems a little funny, but has its reasons...            \n\
107                                                                              \n\
108         // The call to [object class] is here because if this is a           \n\
109         // class, and has not been called into yet, we need to do            \n\
110         // something to force the class to initialize itself.                \n\
111         // Then the call to object_getClass will actually return the         \n\
112         // correct class, either the class if object is a class              \n\
113         // instance, or the meta-class if it is a class pointer.             \n\
114         void *class_ptr = (void *) [(id) object class];                      \n\
115         return_struct.class_addr = (id)  object_getClass((id) object);       \n\
116         if (debug)                                                           \n\
117         {                                                                    \n\
118             if (class_ptr == object)                                         \n\
119             {                                                                \n\
120                 printf (\"Found a class object, need to use the meta class %p -> %p\\n\",\n\
121                         class_ptr, return_struct.class_addr);                \n\
122             }                                                                \n\
123             else                                                             \n\
124             {                                                                \n\
125                  printf (\"[object class] returned: %p object_getClass: %p.\\n\", \n\
126                  class_ptr, return_struct.class_addr);                       \n\
127             }                                                                \n\
128         }                                                                    \n\
129     }                                                                        \n\
130                                                                              \n\
131     if (is_fixup)                                                            \n\
132     {                                                                        \n\
133         if (is_fixed)                                                        \n\
134         {                                                                    \n\
135             return_struct.sel_addr = ((__lldb_msg_ref *) sel)->sel;          \n\
136         }                                                                    \n\
137         else                                                                 \n\
138         {                                                                    \n\
139             char *sel_name = (char *) ((__lldb_msg_ref *) sel)->sel;         \n\
140             return_struct.sel_addr = sel_getUid (sel_name);                  \n\
141             if (debug)                                                       \n\
142                 printf (\"\\n*** Got fixed up selector: %p for name %s.\\n\",\n\
143                         return_struct.sel_addr, sel_name);                   \n\
144         }                                                                    \n\
145     }                                                                        \n\
146     else                                                                     \n\
147     {                                                                        \n\
148         return_struct.sel_addr = sel;                                        \n\
149     }                                                                        \n\
150                                                                              \n\
151     if (is_stret)                                                            \n\
152     {                                                                        \n\
153         return_struct.impl_addr =                                            \n\
154           class_getMethodImplementation_stret (return_struct.class_addr,     \n\
155                                                return_struct.sel_addr);      \n\
156     }                                                                        \n\
157     else                                                                     \n\
158     {                                                                        \n\
159         return_struct.impl_addr =                                            \n\
160             class_getMethodImplementation (return_struct.class_addr,         \n\
161                                            return_struct.sel_addr);          \n\
162     }                                                                        \n\
163     if (debug)                                                               \n\
164         printf (\"\\n*** Returning implementation: %p.\\n\",                 \n\
165                           return_struct.impl_addr);                          \n\
166                                                                              \n\
167     return return_struct.impl_addr;                                          \n\
168 }                                                                            \n\
169 ";
170 const char *
171     AppleObjCTrampolineHandler::g_lookup_implementation_no_stret_function_code =
172         "                      \n\
173 extern \"C\"                                                                 \n\
174 {                                                                            \n\
175     extern void *class_getMethodImplementation(void *objc_class, void *sel); \n\
176     extern void * object_getClass (id object);                               \n\
177     extern void * sel_getUid(char *name);                                    \n\
178     extern int printf(const char *format, ...);                              \n\
179 }                                                                            \n\
180 extern \"C\" void * __lldb_objc_find_implementation_for_selector (void *object,                                 \n\
181                                                     void *sel,               \n\
182                                                     int is_stret,            \n\
183                                                     int is_super,            \n\
184                                                     int is_super2,           \n\
185                                                     int is_fixup,            \n\
186                                                     int is_fixed,            \n\
187                                                     int debug)               \n\
188 {                                                                            \n\
189     struct __lldb_imp_return_struct                                          \n\
190     {                                                                        \n\
191         void *class_addr;                                                    \n\
192         void *sel_addr;                                                      \n\
193         void *impl_addr;                                                     \n\
194     };                                                                       \n\
195                                                                              \n\
196     struct __lldb_objc_class {                                               \n\
197         void *isa;                                                           \n\
198         void *super_ptr;                                                     \n\
199     };                                                                       \n\
200     struct __lldb_objc_super {                                               \n\
201         void *receiver;                                                      \n\
202         struct __lldb_objc_class *class_ptr;                                 \n\
203     };                                                                       \n\
204     struct __lldb_msg_ref {                                                  \n\
205         void *dont_know;                                                     \n\
206         void *sel;                                                           \n\
207     };                                                                       \n\
208                                                                              \n\
209     struct __lldb_imp_return_struct return_struct;                           \n\
210                                                                              \n\
211     if (debug)                                                               \n\
212         printf (\"\\n*** Called with obj: 0x%p sel: 0x%p is_stret: %d is_super: %d, \"                          \n\
213                 \"is_super2: %d, is_fixup: %d, is_fixed: %d\\n\",            \n\
214                  object, sel, is_stret, is_super, is_super2, is_fixup, is_fixed);                               \n\
215     if (is_super)                                                            \n\
216     {                                                                        \n\
217         if (is_super2)                                                       \n\
218         {                                                                    \n\
219             return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr->super_ptr;                    \n\
220         }                                                                    \n\
221         else                                                                 \n\
222         {                                                                    \n\
223             return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr;                               \n\
224         }                                                                    \n\
225     }                                                                        \n\
226     else                                                                     \n\
227     {                                                                        \n\
228         // This code seems a little funny, but has its reasons...            \n\
229         // The call to [object class] is here because if this is a class, and has not been called into          \n\
230         // yet, we need to do something to force the class to initialize itself.                                \n\
231         // Then the call to object_getClass will actually return the correct class, either the class            \n\
232         // if object is a class instance, or the meta-class if it is a class pointer.                           \n\
233         void *class_ptr = (void *) [(id) object class];                      \n\
234         return_struct.class_addr = (id)  object_getClass((id) object);       \n\
235         if (debug)                                                           \n\
236         {                                                                    \n\
237             if (class_ptr == object)                                         \n\
238             {                                                                \n\
239                 printf (\"Found a class object, need to return the meta class %p -> %p\\n\",                    \n\
240                         class_ptr, return_struct.class_addr);                \n\
241             }                                                                \n\
242             else                                                             \n\
243             {                                                                \n\
244                  printf (\"[object class] returned: %p object_getClass: %p.\\n\",                               \n\
245                  class_ptr, return_struct.class_addr);                       \n\
246             }                                                                \n\
247         }                                                                    \n\
248     }                                                                        \n\
249                                                                              \n\
250     if (is_fixup)                                                            \n\
251     {                                                                        \n\
252         if (is_fixed)                                                        \n\
253         {                                                                    \n\
254             return_struct.sel_addr = ((__lldb_msg_ref *) sel)->sel;          \n\
255         }                                                                    \n\
256         else                                                                 \n\
257         {                                                                    \n\
258             char *sel_name = (char *) ((__lldb_msg_ref *) sel)->sel;         \n\
259             return_struct.sel_addr = sel_getUid (sel_name);                  \n\
260             if (debug)                                                       \n\
261                 printf (\"\\n*** Got fixed up selector: %p for name %s.\\n\",\n\
262                         return_struct.sel_addr, sel_name);                   \n\
263         }                                                                    \n\
264     }                                                                        \n\
265     else                                                                     \n\
266     {                                                                        \n\
267         return_struct.sel_addr = sel;                                        \n\
268     }                                                                        \n\
269                                                                              \n\
270     return_struct.impl_addr =                                                \n\
271       class_getMethodImplementation (return_struct.class_addr,               \n\
272                                      return_struct.sel_addr);                \n\
273     if (debug)                                                               \n\
274         printf (\"\\n*** Returning implementation: 0x%p.\\n\",               \n\
275           return_struct.impl_addr);                                          \n\
276                                                                              \n\
277     return return_struct.impl_addr;                                          \n\
278 }                                                                            \n\
279 ";
280 
VTableRegion(AppleObjCVTables * owner,lldb::addr_t header_addr)281 AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::VTableRegion(
282     AppleObjCVTables *owner, lldb::addr_t header_addr)
283     : m_valid(true), m_owner(owner), m_header_addr(header_addr),
284       m_code_start_addr(0), m_code_end_addr(0), m_next_region(0) {
285   SetUpRegion();
286 }
287 
~AppleObjCTrampolineHandler()288 AppleObjCTrampolineHandler::~AppleObjCTrampolineHandler() {}
289 
SetUpRegion()290 void AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::SetUpRegion() {
291   // The header looks like:
292   //
293   //   uint16_t headerSize
294   //   uint16_t descSize
295   //   uint32_t descCount
296   //   void * next
297   //
298   // First read in the header:
299 
300   char memory_buffer[16];
301   ProcessSP process_sp = m_owner->GetProcessSP();
302   if (!process_sp)
303     return;
304   DataExtractor data(memory_buffer, sizeof(memory_buffer),
305                      process_sp->GetByteOrder(),
306                      process_sp->GetAddressByteSize());
307   size_t actual_size = 8 + process_sp->GetAddressByteSize();
308   Status error;
309   size_t bytes_read =
310       process_sp->ReadMemory(m_header_addr, memory_buffer, actual_size, error);
311   if (bytes_read != actual_size) {
312     m_valid = false;
313     return;
314   }
315 
316   lldb::offset_t offset = 0;
317   const uint16_t header_size = data.GetU16(&offset);
318   const uint16_t descriptor_size = data.GetU16(&offset);
319   const size_t num_descriptors = data.GetU32(&offset);
320 
321   m_next_region = data.GetAddress(&offset);
322 
323   // If the header size is 0, that means we've come in too early before this
324   // data is set up.
325   // Set ourselves as not valid, and continue.
326   if (header_size == 0 || num_descriptors == 0) {
327     m_valid = false;
328     return;
329   }
330 
331   // Now read in all the descriptors:
332   // The descriptor looks like:
333   //
334   // uint32_t offset
335   // uint32_t flags
336   //
337   // Where offset is either 0 - in which case it is unused, or it is
338   // the offset of the vtable code from the beginning of the
339   // descriptor record.  Below, we'll convert that into an absolute
340   // code address, since I don't want to have to compute it over and
341   // over.
342 
343   // Ingest the whole descriptor array:
344   const lldb::addr_t desc_ptr = m_header_addr + header_size;
345   const size_t desc_array_size = num_descriptors * descriptor_size;
346   DataBufferSP data_sp(new DataBufferHeap(desc_array_size, '\0'));
347   uint8_t *dst = (uint8_t *)data_sp->GetBytes();
348 
349   DataExtractor desc_extractor(dst, desc_array_size, process_sp->GetByteOrder(),
350                                process_sp->GetAddressByteSize());
351   bytes_read = process_sp->ReadMemory(desc_ptr, dst, desc_array_size, error);
352   if (bytes_read != desc_array_size) {
353     m_valid = false;
354     return;
355   }
356 
357   // The actual code for the vtables will be laid out consecutively, so I also
358   // compute the start and end of the whole code block.
359 
360   offset = 0;
361   m_code_start_addr = 0;
362   m_code_end_addr = 0;
363 
364   for (size_t i = 0; i < num_descriptors; i++) {
365     lldb::addr_t start_offset = offset;
366     uint32_t voffset = desc_extractor.GetU32(&offset);
367     uint32_t flags = desc_extractor.GetU32(&offset);
368     lldb::addr_t code_addr = desc_ptr + start_offset + voffset;
369     m_descriptors.push_back(VTableDescriptor(flags, code_addr));
370 
371     if (m_code_start_addr == 0 || code_addr < m_code_start_addr)
372       m_code_start_addr = code_addr;
373     if (code_addr > m_code_end_addr)
374       m_code_end_addr = code_addr;
375 
376     offset = start_offset + descriptor_size;
377   }
378   // Finally, a little bird told me that all the vtable code blocks
379   // are the same size.  Let's compute the blocks and if they are all
380   // the same add the size to the code end address:
381   lldb::addr_t code_size = 0;
382   bool all_the_same = true;
383   for (size_t i = 0; i < num_descriptors - 1; i++) {
384     lldb::addr_t this_size =
385         m_descriptors[i + 1].code_start - m_descriptors[i].code_start;
386     if (code_size == 0)
387       code_size = this_size;
388     else {
389       if (this_size != code_size)
390         all_the_same = false;
391       if (this_size > code_size)
392         code_size = this_size;
393     }
394   }
395   if (all_the_same)
396     m_code_end_addr += code_size;
397 }
398 
399 bool AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::
AddressInRegion(lldb::addr_t addr,uint32_t & flags)400     AddressInRegion(lldb::addr_t addr, uint32_t &flags) {
401   if (!IsValid())
402     return false;
403 
404   if (addr < m_code_start_addr || addr > m_code_end_addr)
405     return false;
406 
407   std::vector<VTableDescriptor>::iterator pos, end = m_descriptors.end();
408   for (pos = m_descriptors.begin(); pos != end; pos++) {
409     if (addr <= (*pos).code_start) {
410       flags = (*pos).flags;
411       return true;
412     }
413   }
414   return false;
415 }
416 
Dump(Stream & s)417 void AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::Dump(
418     Stream &s) {
419   s.Printf("Header addr: 0x%" PRIx64 " Code start: 0x%" PRIx64
420            " Code End: 0x%" PRIx64 " Next: 0x%" PRIx64 "\n",
421            m_header_addr, m_code_start_addr, m_code_end_addr, m_next_region);
422   size_t num_elements = m_descriptors.size();
423   for (size_t i = 0; i < num_elements; i++) {
424     s.Indent();
425     s.Printf("Code start: 0x%" PRIx64 " Flags: %d\n",
426              m_descriptors[i].code_start, m_descriptors[i].flags);
427   }
428 }
429 
AppleObjCVTables(const ProcessSP & process_sp,const ModuleSP & objc_module_sp)430 AppleObjCTrampolineHandler::AppleObjCVTables::AppleObjCVTables(
431     const ProcessSP &process_sp, const ModuleSP &objc_module_sp)
432     : m_process_wp(), m_trampoline_header(LLDB_INVALID_ADDRESS),
433       m_trampolines_changed_bp_id(LLDB_INVALID_BREAK_ID),
434       m_objc_module_sp(objc_module_sp) {
435   if (process_sp)
436     m_process_wp = process_sp;
437 }
438 
~AppleObjCVTables()439 AppleObjCTrampolineHandler::AppleObjCVTables::~AppleObjCVTables() {
440   ProcessSP process_sp = GetProcessSP();
441   if (process_sp) {
442     if (m_trampolines_changed_bp_id != LLDB_INVALID_BREAK_ID)
443       process_sp->GetTarget().RemoveBreakpointByID(m_trampolines_changed_bp_id);
444   }
445 }
446 
InitializeVTableSymbols()447 bool AppleObjCTrampolineHandler::AppleObjCVTables::InitializeVTableSymbols() {
448   if (m_trampoline_header != LLDB_INVALID_ADDRESS)
449     return true;
450 
451   ProcessSP process_sp = GetProcessSP();
452   if (process_sp) {
453     Target &target = process_sp->GetTarget();
454 
455     const ModuleList &target_modules = target.GetImages();
456     std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
457     size_t num_modules = target_modules.GetSize();
458     if (!m_objc_module_sp) {
459       for (size_t i = 0; i < num_modules; i++) {
460         if (ObjCLanguageRuntime::Get(*process_sp)
461                 ->IsModuleObjCLibrary(
462                     target_modules.GetModuleAtIndexUnlocked(i))) {
463           m_objc_module_sp = target_modules.GetModuleAtIndexUnlocked(i);
464           break;
465         }
466       }
467     }
468 
469     if (m_objc_module_sp) {
470       ConstString trampoline_name("gdb_objc_trampolines");
471       const Symbol *trampoline_symbol =
472           m_objc_module_sp->FindFirstSymbolWithNameAndType(trampoline_name,
473                                                            eSymbolTypeData);
474       if (trampoline_symbol != nullptr) {
475         m_trampoline_header = trampoline_symbol->GetLoadAddress(&target);
476         if (m_trampoline_header == LLDB_INVALID_ADDRESS)
477           return false;
478 
479         // Next look up the "changed" symbol and set a breakpoint on that...
480         ConstString changed_name("gdb_objc_trampolines_changed");
481         const Symbol *changed_symbol =
482             m_objc_module_sp->FindFirstSymbolWithNameAndType(changed_name,
483                                                              eSymbolTypeCode);
484         if (changed_symbol != nullptr) {
485           const Address changed_symbol_addr = changed_symbol->GetAddress();
486           if (!changed_symbol_addr.IsValid())
487             return false;
488 
489           lldb::addr_t changed_addr =
490               changed_symbol_addr.GetOpcodeLoadAddress(&target);
491           if (changed_addr != LLDB_INVALID_ADDRESS) {
492             BreakpointSP trampolines_changed_bp_sp =
493                 target.CreateBreakpoint(changed_addr, true, false);
494             if (trampolines_changed_bp_sp) {
495               m_trampolines_changed_bp_id = trampolines_changed_bp_sp->GetID();
496               trampolines_changed_bp_sp->SetCallback(RefreshTrampolines, this,
497                                                      true);
498               trampolines_changed_bp_sp->SetBreakpointKind(
499                   "objc-trampolines-changed");
500               return true;
501             }
502           }
503         }
504       }
505     }
506   }
507   return false;
508 }
509 
RefreshTrampolines(void * baton,StoppointCallbackContext * context,lldb::user_id_t break_id,lldb::user_id_t break_loc_id)510 bool AppleObjCTrampolineHandler::AppleObjCVTables::RefreshTrampolines(
511     void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
512     lldb::user_id_t break_loc_id) {
513   AppleObjCVTables *vtable_handler = (AppleObjCVTables *)baton;
514   if (vtable_handler->InitializeVTableSymbols()) {
515     // The Update function is called with the address of an added region.  So we
516     // grab that address, and
517     // feed it into ReadRegions.  Of course, our friend the ABI will get the
518     // values for us.
519     ExecutionContext exe_ctx(context->exe_ctx_ref);
520     Process *process = exe_ctx.GetProcessPtr();
521     const ABI *abi = process->GetABI().get();
522 
523     TypeSystemClang *clang_ast_context =
524         ScratchTypeSystemClang::GetForTarget(process->GetTarget());
525     if (!clang_ast_context)
526       return false;
527 
528     ValueList argument_values;
529     Value input_value;
530     CompilerType clang_void_ptr_type =
531         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
532 
533     input_value.SetValueType(Value::eValueTypeScalar);
534     // input_value.SetContext (Value::eContextTypeClangType,
535     // clang_void_ptr_type);
536     input_value.SetCompilerType(clang_void_ptr_type);
537     argument_values.PushValue(input_value);
538 
539     bool success =
540         abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values);
541     if (!success)
542       return false;
543 
544     // Now get a pointer value from the zeroth argument.
545     Status error;
546     DataExtractor data;
547     error = argument_values.GetValueAtIndex(0)->GetValueAsData(&exe_ctx, data,
548                                                                nullptr);
549     lldb::offset_t offset = 0;
550     lldb::addr_t region_addr = data.GetAddress(&offset);
551 
552     if (region_addr != 0)
553       vtable_handler->ReadRegions(region_addr);
554   }
555   return false;
556 }
557 
ReadRegions()558 bool AppleObjCTrampolineHandler::AppleObjCVTables::ReadRegions() {
559   // The no argument version reads the  start region from the value of
560   // the gdb_regions_header, and gets started from there.
561 
562   m_regions.clear();
563   if (!InitializeVTableSymbols())
564     return false;
565   Status error;
566   ProcessSP process_sp = GetProcessSP();
567   if (process_sp) {
568     lldb::addr_t region_addr =
569         process_sp->ReadPointerFromMemory(m_trampoline_header, error);
570     if (error.Success())
571       return ReadRegions(region_addr);
572   }
573   return false;
574 }
575 
ReadRegions(lldb::addr_t region_addr)576 bool AppleObjCTrampolineHandler::AppleObjCVTables::ReadRegions(
577     lldb::addr_t region_addr) {
578   ProcessSP process_sp = GetProcessSP();
579   if (!process_sp)
580     return false;
581 
582   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
583 
584   // We aren't starting at the trampoline symbol.
585   InitializeVTableSymbols();
586   lldb::addr_t next_region = region_addr;
587 
588   // Read in the sizes of the headers.
589   while (next_region != 0) {
590     m_regions.push_back(VTableRegion(this, next_region));
591     if (!m_regions.back().IsValid()) {
592       m_regions.clear();
593       return false;
594     }
595     if (log) {
596       StreamString s;
597       m_regions.back().Dump(s);
598       LLDB_LOGF(log, "Read vtable region: \n%s", s.GetData());
599     }
600 
601     next_region = m_regions.back().GetNextRegionAddr();
602   }
603 
604   return true;
605 }
606 
IsAddressInVTables(lldb::addr_t addr,uint32_t & flags)607 bool AppleObjCTrampolineHandler::AppleObjCVTables::IsAddressInVTables(
608     lldb::addr_t addr, uint32_t &flags) {
609   region_collection::iterator pos, end = m_regions.end();
610   for (pos = m_regions.begin(); pos != end; pos++) {
611     if ((*pos).AddressInRegion(addr, flags))
612       return true;
613   }
614   return false;
615 }
616 
617 const AppleObjCTrampolineHandler::DispatchFunction
618     AppleObjCTrampolineHandler::g_dispatch_functions[] = {
619         // NAME                              STRET  SUPER  SUPER2  FIXUP TYPE
620         {"objc_msgSend", false, false, false, DispatchFunction::eFixUpNone},
621         {"objc_msgSend_fixup", false, false, false,
622          DispatchFunction::eFixUpToFix},
623         {"objc_msgSend_fixedup", false, false, false,
624          DispatchFunction::eFixUpFixed},
625         {"objc_msgSend_stret", true, false, false,
626          DispatchFunction::eFixUpNone},
627         {"objc_msgSend_stret_fixup", true, false, false,
628          DispatchFunction::eFixUpToFix},
629         {"objc_msgSend_stret_fixedup", true, false, false,
630          DispatchFunction::eFixUpFixed},
631         {"objc_msgSend_fpret", false, false, false,
632          DispatchFunction::eFixUpNone},
633         {"objc_msgSend_fpret_fixup", false, false, false,
634          DispatchFunction::eFixUpToFix},
635         {"objc_msgSend_fpret_fixedup", false, false, false,
636          DispatchFunction::eFixUpFixed},
637         {"objc_msgSend_fp2ret", false, false, true,
638          DispatchFunction::eFixUpNone},
639         {"objc_msgSend_fp2ret_fixup", false, false, true,
640          DispatchFunction::eFixUpToFix},
641         {"objc_msgSend_fp2ret_fixedup", false, false, true,
642          DispatchFunction::eFixUpFixed},
643         {"objc_msgSendSuper", false, true, false, DispatchFunction::eFixUpNone},
644         {"objc_msgSendSuper_stret", true, true, false,
645          DispatchFunction::eFixUpNone},
646         {"objc_msgSendSuper2", false, true, true, DispatchFunction::eFixUpNone},
647         {"objc_msgSendSuper2_fixup", false, true, true,
648          DispatchFunction::eFixUpToFix},
649         {"objc_msgSendSuper2_fixedup", false, true, true,
650          DispatchFunction::eFixUpFixed},
651         {"objc_msgSendSuper2_stret", true, true, true,
652          DispatchFunction::eFixUpNone},
653         {"objc_msgSendSuper2_stret_fixup", true, true, true,
654          DispatchFunction::eFixUpToFix},
655         {"objc_msgSendSuper2_stret_fixedup", true, true, true,
656          DispatchFunction::eFixUpFixed},
657 };
658 
659 // This is the table of ObjC "accelerated dispatch" functions.  They are a set
660 // of objc methods that are "seldom overridden" and so the compiler replaces the
661 // objc_msgSend with a call to one of the dispatch functions.  That will check
662 // whether the method has been overridden, and directly call the Foundation
663 // implementation if not.
664 // This table is supposed to be complete.  If ones get added in the future, we
665 // will have to add them to the table.
666 const char *AppleObjCTrampolineHandler::g_opt_dispatch_names[] = {
667     "objc_alloc",
668     "objc_autorelease",
669     "objc_release",
670     "objc_retain",
671     "objc_alloc_init",
672     "objc_allocWithZone",
673     "objc_opt_class",
674     "objc_opt_isKindOfClass",
675     "objc_opt_new",
676     "objc_opt_respondsToSelector",
677     "objc_opt_self",
678 };
679 
AppleObjCTrampolineHandler(const ProcessSP & process_sp,const ModuleSP & objc_module_sp)680 AppleObjCTrampolineHandler::AppleObjCTrampolineHandler(
681     const ProcessSP &process_sp, const ModuleSP &objc_module_sp)
682     : m_process_wp(), m_objc_module_sp(objc_module_sp),
683       m_lookup_implementation_function_code(nullptr),
684       m_impl_fn_addr(LLDB_INVALID_ADDRESS),
685       m_impl_stret_fn_addr(LLDB_INVALID_ADDRESS),
686       m_msg_forward_addr(LLDB_INVALID_ADDRESS) {
687   if (process_sp)
688     m_process_wp = process_sp;
689   // Look up the known resolution functions:
690 
691   ConstString get_impl_name("class_getMethodImplementation");
692   ConstString get_impl_stret_name("class_getMethodImplementation_stret");
693   ConstString msg_forward_name("_objc_msgForward");
694   ConstString msg_forward_stret_name("_objc_msgForward_stret");
695 
696   Target *target = process_sp ? &process_sp->GetTarget() : nullptr;
697   const Symbol *class_getMethodImplementation =
698       m_objc_module_sp->FindFirstSymbolWithNameAndType(get_impl_name,
699                                                        eSymbolTypeCode);
700   const Symbol *class_getMethodImplementation_stret =
701       m_objc_module_sp->FindFirstSymbolWithNameAndType(get_impl_stret_name,
702                                                        eSymbolTypeCode);
703   const Symbol *msg_forward = m_objc_module_sp->FindFirstSymbolWithNameAndType(
704       msg_forward_name, eSymbolTypeCode);
705   const Symbol *msg_forward_stret =
706       m_objc_module_sp->FindFirstSymbolWithNameAndType(msg_forward_stret_name,
707                                                        eSymbolTypeCode);
708 
709   if (class_getMethodImplementation)
710     m_impl_fn_addr =
711         class_getMethodImplementation->GetAddress().GetOpcodeLoadAddress(
712             target);
713   if (class_getMethodImplementation_stret)
714     m_impl_stret_fn_addr =
715         class_getMethodImplementation_stret->GetAddress().GetOpcodeLoadAddress(
716             target);
717   if (msg_forward)
718     m_msg_forward_addr = msg_forward->GetAddress().GetOpcodeLoadAddress(target);
719   if (msg_forward_stret)
720     m_msg_forward_stret_addr =
721         msg_forward_stret->GetAddress().GetOpcodeLoadAddress(target);
722 
723   // FIXME: Do some kind of logging here.
724   if (m_impl_fn_addr == LLDB_INVALID_ADDRESS) {
725     // If we can't even find the ordinary get method implementation function,
726     // then we aren't going to be able to
727     // step through any method dispatches.  Warn to that effect and get out of
728     // here.
729     if (process_sp->CanJIT()) {
730       process_sp->GetTarget().GetDebugger().GetErrorStream().Printf(
731           "Could not find implementation lookup function \"%s\""
732           " step in through ObjC method dispatch will not work.\n",
733           get_impl_name.AsCString());
734     }
735     return;
736   } else if (m_impl_stret_fn_addr == LLDB_INVALID_ADDRESS) {
737     // It there is no stret return lookup function, assume that it is the same
738     // as the straight lookup:
739     m_impl_stret_fn_addr = m_impl_fn_addr;
740     // Also we will use the version of the lookup code that doesn't rely on the
741     // stret version of the function.
742     m_lookup_implementation_function_code =
743         g_lookup_implementation_no_stret_function_code;
744   } else {
745     m_lookup_implementation_function_code =
746         g_lookup_implementation_with_stret_function_code;
747   }
748 
749   // Look up the addresses for the objc dispatch functions and cache
750   // them.  For now I'm inspecting the symbol names dynamically to
751   // figure out how to dispatch to them.  If it becomes more
752   // complicated than this we can turn the g_dispatch_functions char *
753   // array into a template table, and populate the DispatchFunction
754   // map from there.
755 
756   for (size_t i = 0; i != llvm::array_lengthof(g_dispatch_functions); i++) {
757     ConstString name_const_str(g_dispatch_functions[i].name);
758     const Symbol *msgSend_symbol =
759         m_objc_module_sp->FindFirstSymbolWithNameAndType(name_const_str,
760                                                          eSymbolTypeCode);
761     if (msgSend_symbol && msgSend_symbol->ValueIsAddress()) {
762       // FIXME: Make g_dispatch_functions static table of
763       // DispatchFunctions, and have the map be address->index.
764       // Problem is we also need to lookup the dispatch function.  For
765       // now we could have a side table of stret & non-stret dispatch
766       // functions.  If that's as complex as it gets, we're fine.
767 
768       lldb::addr_t sym_addr =
769           msgSend_symbol->GetAddressRef().GetOpcodeLoadAddress(target);
770 
771       m_msgSend_map.insert(std::pair<lldb::addr_t, int>(sym_addr, i));
772     }
773   }
774 
775   // Similarly, cache the addresses of the "optimized dispatch" function.
776   for (size_t i = 0; i != llvm::array_lengthof(g_opt_dispatch_names); i++) {
777     ConstString name_const_str(g_opt_dispatch_names[i]);
778     const Symbol *msgSend_symbol =
779         m_objc_module_sp->FindFirstSymbolWithNameAndType(name_const_str,
780                                                          eSymbolTypeCode);
781     if (msgSend_symbol && msgSend_symbol->ValueIsAddress()) {
782       lldb::addr_t sym_addr =
783           msgSend_symbol->GetAddressRef().GetOpcodeLoadAddress(target);
784 
785       m_opt_dispatch_map.emplace(sym_addr, i);
786     }
787   }
788 
789   // Build our vtable dispatch handler here:
790   m_vtables_up =
791       std::make_unique<AppleObjCVTables>(process_sp, m_objc_module_sp);
792   if (m_vtables_up)
793     m_vtables_up->ReadRegions();
794 }
795 
796 lldb::addr_t
SetupDispatchFunction(Thread & thread,ValueList & dispatch_values)797 AppleObjCTrampolineHandler::SetupDispatchFunction(Thread &thread,
798                                                   ValueList &dispatch_values) {
799   ThreadSP thread_sp(thread.shared_from_this());
800   ExecutionContext exe_ctx(thread_sp);
801   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
802 
803   lldb::addr_t args_addr = LLDB_INVALID_ADDRESS;
804   FunctionCaller *impl_function_caller = nullptr;
805 
806   // Scope for mutex locker:
807   {
808     std::lock_guard<std::mutex> guard(m_impl_function_mutex);
809 
810     // First stage is to make the ClangUtility to hold our injected function:
811 
812     if (!m_impl_code) {
813       if (m_lookup_implementation_function_code != nullptr) {
814         auto utility_fn_or_error = exe_ctx.GetTargetRef().CreateUtilityFunction(
815             m_lookup_implementation_function_code,
816             g_lookup_implementation_function_name, eLanguageTypeC, exe_ctx);
817         if (!utility_fn_or_error) {
818           LLDB_LOG_ERROR(
819               log, utility_fn_or_error.takeError(),
820               "Failed to get Utility Function for implementation lookup: {0}.");
821           return args_addr;
822         }
823         m_impl_code = std::move(*utility_fn_or_error);
824       } else {
825         LLDB_LOGF(log, "No method lookup implementation code.");
826         return LLDB_INVALID_ADDRESS;
827       }
828 
829       // Next make the runner function for our implementation utility function.
830       TypeSystemClang *clang_ast_context = ScratchTypeSystemClang::GetForTarget(
831           thread.GetProcess()->GetTarget());
832       if (!clang_ast_context)
833         return LLDB_INVALID_ADDRESS;
834 
835       CompilerType clang_void_ptr_type =
836           clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
837       Status error;
838 
839       impl_function_caller = m_impl_code->MakeFunctionCaller(
840           clang_void_ptr_type, dispatch_values, thread_sp, error);
841       if (error.Fail()) {
842         LLDB_LOGF(log,
843                   "Error getting function caller for dispatch lookup: \"%s\".",
844                   error.AsCString());
845         return args_addr;
846       }
847     } else {
848       impl_function_caller = m_impl_code->GetFunctionCaller();
849     }
850   }
851 
852   // Now write down the argument values for this particular call.
853   // This looks like it might be a race condition if other threads
854   // were calling into here, but actually it isn't because we allocate
855   // a new args structure for this call by passing args_addr =
856   // LLDB_INVALID_ADDRESS...
857 
858   DiagnosticManager diagnostics;
859   if (!impl_function_caller->WriteFunctionArguments(
860           exe_ctx, args_addr, dispatch_values, diagnostics)) {
861     if (log) {
862       LLDB_LOGF(log, "Error writing function arguments.");
863       diagnostics.Dump(log);
864     }
865     return args_addr;
866   }
867 
868   return args_addr;
869 }
870 
871 const AppleObjCTrampolineHandler::DispatchFunction *
FindDispatchFunction(lldb::addr_t addr)872 AppleObjCTrampolineHandler::FindDispatchFunction(lldb::addr_t addr) {
873   MsgsendMap::iterator pos;
874   pos = m_msgSend_map.find(addr);
875   if (pos != m_msgSend_map.end()) {
876     return &g_dispatch_functions[(*pos).second];
877   }
878   return nullptr;
879 }
880 
881 void
ForEachDispatchFunction(std::function<void (lldb::addr_t,const DispatchFunction &)> callback)882 AppleObjCTrampolineHandler::ForEachDispatchFunction(
883     std::function<void(lldb::addr_t,
884                        const DispatchFunction &)> callback) {
885   for (auto elem : m_msgSend_map) {
886     callback(elem.first, g_dispatch_functions[elem.second]);
887   }
888 }
889 
890 ThreadPlanSP
GetStepThroughDispatchPlan(Thread & thread,bool stop_others)891 AppleObjCTrampolineHandler::GetStepThroughDispatchPlan(Thread &thread,
892                                                        bool stop_others) {
893   ThreadPlanSP ret_plan_sp;
894   lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC();
895 
896   DispatchFunction vtable_dispatch
897       = {"vtable", 0, false, false, DispatchFunction::eFixUpFixed};
898 
899   // First step is to look and see if we are in one of the known ObjC
900   // dispatch functions.  We've already compiled a table of same, so
901   // consult it.
902 
903   const DispatchFunction *this_dispatch = FindDispatchFunction(curr_pc);
904 
905   // Next check to see if we are in a vtable region:
906 
907   if (!this_dispatch && m_vtables_up) {
908     uint32_t flags;
909     if (m_vtables_up->IsAddressInVTables(curr_pc, flags)) {
910       vtable_dispatch.stret_return =
911           (flags & AppleObjCVTables::eOBJC_TRAMPOLINE_STRET) ==
912           AppleObjCVTables::eOBJC_TRAMPOLINE_STRET;
913       this_dispatch = &vtable_dispatch;
914     }
915   }
916 
917   if (this_dispatch) {
918     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
919 
920     // We are decoding a method dispatch.  First job is to pull the
921     // arguments out:
922 
923     lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
924 
925     const ABI *abi = nullptr;
926     ProcessSP process_sp(thread.CalculateProcess());
927     if (process_sp)
928       abi = process_sp->GetABI().get();
929     if (abi == nullptr)
930       return ret_plan_sp;
931 
932     TargetSP target_sp(thread.CalculateTarget());
933 
934     TypeSystemClang *clang_ast_context =
935         ScratchTypeSystemClang::GetForTarget(*target_sp);
936     if (!clang_ast_context)
937       return ret_plan_sp;
938 
939     ValueList argument_values;
940     Value void_ptr_value;
941     CompilerType clang_void_ptr_type =
942         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
943     void_ptr_value.SetValueType(Value::eValueTypeScalar);
944     // void_ptr_value.SetContext (Value::eContextTypeClangType,
945     // clang_void_ptr_type);
946     void_ptr_value.SetCompilerType(clang_void_ptr_type);
947 
948     int obj_index;
949     int sel_index;
950 
951     // If this is a struct return dispatch, then the first argument is
952     // the return struct pointer, and the object is the second, and
953     // the selector is the third.  Otherwise the object is the first
954     // and the selector the second.
955     if (this_dispatch->stret_return) {
956       obj_index = 1;
957       sel_index = 2;
958       argument_values.PushValue(void_ptr_value);
959       argument_values.PushValue(void_ptr_value);
960       argument_values.PushValue(void_ptr_value);
961     } else {
962       obj_index = 0;
963       sel_index = 1;
964       argument_values.PushValue(void_ptr_value);
965       argument_values.PushValue(void_ptr_value);
966     }
967 
968     bool success = abi->GetArgumentValues(thread, argument_values);
969     if (!success)
970       return ret_plan_sp;
971 
972     lldb::addr_t obj_addr =
973         argument_values.GetValueAtIndex(obj_index)->GetScalar().ULongLong();
974     if (obj_addr == 0x0) {
975       LLDB_LOGF(
976           log,
977           "Asked to step to dispatch to nil object, returning empty plan.");
978       return ret_plan_sp;
979     }
980 
981     ExecutionContext exe_ctx(thread.shared_from_this());
982     Process *process = exe_ctx.GetProcessPtr();
983     // isa_addr will store the class pointer that the method is being
984     // dispatched to - so either the class directly or the super class
985     // if this is one of the objc_msgSendSuper flavors.  That's mostly
986     // used to look up the class/selector pair in our cache.
987 
988     lldb::addr_t isa_addr = LLDB_INVALID_ADDRESS;
989     lldb::addr_t sel_addr =
990         argument_values.GetValueAtIndex(sel_index)->GetScalar().ULongLong();
991 
992     // Figure out the class this is being dispatched to and see if
993     // we've already cached this method call, If so we can push a
994     // run-to-address plan directly.  Otherwise we have to figure out
995     // where the implementation lives.
996 
997     if (this_dispatch->is_super) {
998       if (this_dispatch->is_super2) {
999         // In the objc_msgSendSuper2 case, we don't get the object
1000         // directly, we get a structure containing the object and the
1001         // class to which the super message is being sent.  So we need
1002         // to dig the super out of the class and use that.
1003 
1004         Value super_value(*(argument_values.GetValueAtIndex(obj_index)));
1005         super_value.GetScalar() += process->GetAddressByteSize();
1006         super_value.ResolveValue(&exe_ctx);
1007 
1008         if (super_value.GetScalar().IsValid()) {
1009 
1010           // isa_value now holds the class pointer.  The second word of the
1011           // class pointer is the super-class pointer:
1012           super_value.GetScalar() += process->GetAddressByteSize();
1013           super_value.ResolveValue(&exe_ctx);
1014           if (super_value.GetScalar().IsValid())
1015             isa_addr = super_value.GetScalar().ULongLong();
1016           else {
1017             LLDB_LOGF(log, "Failed to extract the super class value from the "
1018                            "class in objc_super.");
1019           }
1020         } else {
1021           LLDB_LOGF(log, "Failed to extract the class value from objc_super.");
1022         }
1023       } else {
1024         // In the objc_msgSendSuper case, we don't get the object
1025         // directly, we get a two element structure containing the
1026         // object and the super class to which the super message is
1027         // being sent.  So the class we want is the second element of
1028         // this structure.
1029 
1030         Value super_value(*(argument_values.GetValueAtIndex(obj_index)));
1031         super_value.GetScalar() += process->GetAddressByteSize();
1032         super_value.ResolveValue(&exe_ctx);
1033 
1034         if (super_value.GetScalar().IsValid()) {
1035           isa_addr = super_value.GetScalar().ULongLong();
1036         } else {
1037           LLDB_LOGF(log, "Failed to extract the class value from objc_super.");
1038         }
1039       }
1040     } else {
1041       // In the direct dispatch case, the object->isa is the class pointer we
1042       // want.
1043 
1044       // This is a little cheesy, but since object->isa is the first field,
1045       // making the object value a load address value and resolving it will get
1046       // the pointer sized data pointed to by that value...
1047 
1048       // Note, it isn't a fatal error not to be able to get the
1049       // address from the object, since this might be a "tagged
1050       // pointer" which isn't a real object, but rather some word
1051       // length encoded dingus.
1052 
1053       Value isa_value(*(argument_values.GetValueAtIndex(obj_index)));
1054 
1055       isa_value.SetValueType(Value::eValueTypeLoadAddress);
1056       isa_value.ResolveValue(&exe_ctx);
1057       if (isa_value.GetScalar().IsValid()) {
1058         isa_addr = isa_value.GetScalar().ULongLong();
1059       } else {
1060         LLDB_LOGF(log, "Failed to extract the isa value from object.");
1061       }
1062     }
1063 
1064     // Okay, we've got the address of the class for which we're resolving this,
1065     // let's see if it's in our cache:
1066     lldb::addr_t impl_addr = LLDB_INVALID_ADDRESS;
1067 
1068     if (isa_addr != LLDB_INVALID_ADDRESS) {
1069       if (log) {
1070         LLDB_LOGF(log,
1071                   "Resolving call for class - 0x%" PRIx64
1072                   " and selector - 0x%" PRIx64,
1073                   isa_addr, sel_addr);
1074       }
1075       ObjCLanguageRuntime *objc_runtime =
1076           ObjCLanguageRuntime::Get(*thread.GetProcess());
1077       assert(objc_runtime != nullptr);
1078 
1079       impl_addr = objc_runtime->LookupInMethodCache(isa_addr, sel_addr);
1080     }
1081 
1082     if (impl_addr != LLDB_INVALID_ADDRESS) {
1083       // Yup, it was in the cache, so we can run to that address directly.
1084 
1085       LLDB_LOGF(log, "Found implementation address in cache: 0x%" PRIx64,
1086                 impl_addr);
1087 
1088       ret_plan_sp = std::make_shared<ThreadPlanRunToAddress>(thread, impl_addr,
1089                                                              stop_others);
1090     } else {
1091       // We haven't seen this class/selector pair yet.  Look it up.
1092       StreamString errors;
1093       Address impl_code_address;
1094 
1095       ValueList dispatch_values;
1096 
1097       // We've will inject a little function in the target that takes the
1098       // object, selector and some flags,
1099       // and figures out the implementation.  Looks like:
1100       //      void *__lldb_objc_find_implementation_for_selector (void *object,
1101       //                                                          void *sel,
1102       //                                                          int is_stret,
1103       //                                                          int is_super,
1104       //                                                          int is_super2,
1105       //                                                          int is_fixup,
1106       //                                                          int is_fixed,
1107       //                                                          int debug)
1108       // So set up the arguments for that call.
1109 
1110       dispatch_values.PushValue(*(argument_values.GetValueAtIndex(obj_index)));
1111       dispatch_values.PushValue(*(argument_values.GetValueAtIndex(sel_index)));
1112 
1113       Value flag_value;
1114       CompilerType clang_int_type =
1115           clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
1116               lldb::eEncodingSint, 32);
1117       flag_value.SetValueType(Value::eValueTypeScalar);
1118       // flag_value.SetContext (Value::eContextTypeClangType, clang_int_type);
1119       flag_value.SetCompilerType(clang_int_type);
1120 
1121       if (this_dispatch->stret_return)
1122         flag_value.GetScalar() = 1;
1123       else
1124         flag_value.GetScalar() = 0;
1125       dispatch_values.PushValue(flag_value);
1126 
1127       if (this_dispatch->is_super)
1128         flag_value.GetScalar() = 1;
1129       else
1130         flag_value.GetScalar() = 0;
1131       dispatch_values.PushValue(flag_value);
1132 
1133       if (this_dispatch->is_super2)
1134         flag_value.GetScalar() = 1;
1135       else
1136         flag_value.GetScalar() = 0;
1137       dispatch_values.PushValue(flag_value);
1138 
1139       switch (this_dispatch->fixedup) {
1140       case DispatchFunction::eFixUpNone:
1141         flag_value.GetScalar() = 0;
1142         dispatch_values.PushValue(flag_value);
1143         dispatch_values.PushValue(flag_value);
1144         break;
1145       case DispatchFunction::eFixUpFixed:
1146         flag_value.GetScalar() = 1;
1147         dispatch_values.PushValue(flag_value);
1148         flag_value.GetScalar() = 1;
1149         dispatch_values.PushValue(flag_value);
1150         break;
1151       case DispatchFunction::eFixUpToFix:
1152         flag_value.GetScalar() = 1;
1153         dispatch_values.PushValue(flag_value);
1154         flag_value.GetScalar() = 0;
1155         dispatch_values.PushValue(flag_value);
1156         break;
1157       }
1158       if (log && log->GetVerbose())
1159         flag_value.GetScalar() = 1;
1160       else
1161         flag_value.GetScalar() = 0; // FIXME - Set to 0 when debugging is done.
1162       dispatch_values.PushValue(flag_value);
1163 
1164       // The step through code might have to fill in the cache, so it
1165       // is not safe to run only one thread.  So we override the
1166       // stop_others value passed in to us here:
1167       const bool trampoline_stop_others = false;
1168       ret_plan_sp = std::make_shared<AppleThreadPlanStepThroughObjCTrampoline>(
1169           thread, *this, dispatch_values, isa_addr, sel_addr,
1170           trampoline_stop_others);
1171       if (log) {
1172         StreamString s;
1173         ret_plan_sp->GetDescription(&s, eDescriptionLevelFull);
1174         LLDB_LOGF(log, "Using ObjC step plan: %s.\n", s.GetData());
1175       }
1176     }
1177   }
1178 
1179   // Finally, check if we have hit an "optimized dispatch" function.  This will
1180   // either directly call the base implementation or dispatch an objc_msgSend
1181   // if the method has been overridden.  So we just do a "step in/step out",
1182   // setting a breakpoint on objc_msgSend, and if we hit the msgSend, we
1183   // will automatically step in again.  That's the job of the
1184   // AppleThreadPlanStepThroughDirectDispatch.
1185   if (!this_dispatch && !ret_plan_sp) {
1186     MsgsendMap::iterator pos;
1187     pos = m_opt_dispatch_map.find(curr_pc);
1188     if (pos != m_opt_dispatch_map.end()) {
1189 
1190       const char *opt_name = g_opt_dispatch_names[(*pos).second];
1191 
1192       bool trampoline_stop_others = false;
1193       LazyBool step_in_should_stop = eLazyBoolCalculate;
1194       ret_plan_sp = std::make_shared<AppleThreadPlanStepThroughDirectDispatch> (
1195           thread, *this, opt_name, trampoline_stop_others, step_in_should_stop);
1196     }
1197   }
1198 
1199   return ret_plan_sp;
1200 }
1201 
1202 FunctionCaller *
GetLookupImplementationFunctionCaller()1203 AppleObjCTrampolineHandler::GetLookupImplementationFunctionCaller() {
1204   return m_impl_code->GetFunctionCaller();
1205 }
1206