1 //===-- AppleObjCRuntime.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 "AppleObjCRuntime.h"
10 #include "AppleObjCRuntimeV1.h"
11 #include "AppleObjCRuntimeV2.h"
12 #include "AppleObjCTrampolineHandler.h"
13 #include "Plugins/Language/ObjC/NSString.h"
14 #include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
15 #include "Plugins/Process/Utility/HistoryThread.h"
16 #include "lldb/Breakpoint/BreakpointLocation.h"
17 #include "lldb/Core/Module.h"
18 #include "lldb/Core/ModuleList.h"
19 #include "lldb/Core/PluginManager.h"
20 #include "lldb/Core/Section.h"
21 #include "lldb/Core/ValueObject.h"
22 #include "lldb/Core/ValueObjectConstResult.h"
23 #include "lldb/DataFormatters/FormattersHelpers.h"
24 #include "lldb/Expression/DiagnosticManager.h"
25 #include "lldb/Expression/FunctionCaller.h"
26 #include "lldb/Symbol/ObjectFile.h"
27 #include "lldb/Target/ExecutionContext.h"
28 #include "lldb/Target/Process.h"
29 #include "lldb/Target/RegisterContext.h"
30 #include "lldb/Target/StopInfo.h"
31 #include "lldb/Target/Target.h"
32 #include "lldb/Target/Thread.h"
33 #include "lldb/Utility/ConstString.h"
34 #include "lldb/Utility/LLDBLog.h"
35 #include "lldb/Utility/Log.h"
36 #include "lldb/Utility/Scalar.h"
37 #include "lldb/Utility/Status.h"
38 #include "lldb/Utility/StreamString.h"
39 #include "clang/AST/Type.h"
40 
41 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
42 
43 #include <vector>
44 
45 using namespace lldb;
46 using namespace lldb_private;
47 
48 LLDB_PLUGIN_DEFINE(AppleObjCRuntime)
49 
50 char AppleObjCRuntime::ID = 0;
51 
52 AppleObjCRuntime::~AppleObjCRuntime() = default;
53 
AppleObjCRuntime(Process * process)54 AppleObjCRuntime::AppleObjCRuntime(Process *process)
55     : ObjCLanguageRuntime(process), m_read_objc_library(false),
56       m_objc_trampoline_handler_up(), m_Foundation_major() {
57   ReadObjCLibraryIfNeeded(process->GetTarget().GetImages());
58 }
59 
Initialize()60 void AppleObjCRuntime::Initialize() {
61   AppleObjCRuntimeV2::Initialize();
62   AppleObjCRuntimeV1::Initialize();
63 }
64 
Terminate()65 void AppleObjCRuntime::Terminate() {
66   AppleObjCRuntimeV2::Terminate();
67   AppleObjCRuntimeV1::Terminate();
68 }
69 
GetObjectDescription(Stream & str,ValueObject & valobj)70 bool AppleObjCRuntime::GetObjectDescription(Stream &str, ValueObject &valobj) {
71   CompilerType compiler_type(valobj.GetCompilerType());
72   bool is_signed;
73   // ObjC objects can only be pointers (or numbers that actually represents
74   // pointers but haven't been typecast, because reasons..)
75   if (!compiler_type.IsIntegerType(is_signed) && !compiler_type.IsPointerType())
76     return false;
77 
78   // Make the argument list: we pass one arg, the address of our pointer, to
79   // the print function.
80   Value val;
81 
82   if (!valobj.ResolveValue(val.GetScalar()))
83     return false;
84 
85   // Value Objects may not have a process in their ExecutionContextRef.  But we
86   // need to have one in the ref we pass down to eventually call description.
87   // Get it from the target if it isn't present.
88   ExecutionContext exe_ctx;
89   if (valobj.GetProcessSP()) {
90     exe_ctx = ExecutionContext(valobj.GetExecutionContextRef());
91   } else {
92     exe_ctx.SetContext(valobj.GetTargetSP(), true);
93     if (!exe_ctx.HasProcessScope())
94       return false;
95   }
96   return GetObjectDescription(str, val, exe_ctx.GetBestExecutionContextScope());
97 }
GetObjectDescription(Stream & strm,Value & value,ExecutionContextScope * exe_scope)98 bool AppleObjCRuntime::GetObjectDescription(Stream &strm, Value &value,
99                                             ExecutionContextScope *exe_scope) {
100   if (!m_read_objc_library)
101     return false;
102 
103   ExecutionContext exe_ctx;
104   exe_scope->CalculateExecutionContext(exe_ctx);
105   Process *process = exe_ctx.GetProcessPtr();
106   if (!process)
107     return false;
108 
109   // We need other parts of the exe_ctx, but the processes have to match.
110   assert(m_process == process);
111 
112   // Get the function address for the print function.
113   const Address *function_address = GetPrintForDebuggerAddr();
114   if (!function_address)
115     return false;
116 
117   Target *target = exe_ctx.GetTargetPtr();
118   CompilerType compiler_type = value.GetCompilerType();
119   if (compiler_type) {
120     if (!TypeSystemClang::IsObjCObjectPointerType(compiler_type)) {
121       strm.Printf("Value doesn't point to an ObjC object.\n");
122       return false;
123     }
124   } else {
125     // If it is not a pointer, see if we can make it into a pointer.
126     TypeSystemClang *ast_context =
127         ScratchTypeSystemClang::GetForTarget(*target);
128     if (!ast_context)
129       return false;
130 
131     CompilerType opaque_type = ast_context->GetBasicType(eBasicTypeObjCID);
132     if (!opaque_type)
133       opaque_type = ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
134     // value.SetContext(Value::eContextTypeClangType, opaque_type_ptr);
135     value.SetCompilerType(opaque_type);
136   }
137 
138   ValueList arg_value_list;
139   arg_value_list.PushValue(value);
140 
141   // This is the return value:
142   TypeSystemClang *ast_context = ScratchTypeSystemClang::GetForTarget(*target);
143   if (!ast_context)
144     return false;
145 
146   CompilerType return_compiler_type = ast_context->GetCStringType(true);
147   Value ret;
148   //    ret.SetContext(Value::eContextTypeClangType, return_compiler_type);
149   ret.SetCompilerType(return_compiler_type);
150 
151   if (exe_ctx.GetFramePtr() == nullptr) {
152     Thread *thread = exe_ctx.GetThreadPtr();
153     if (thread == nullptr) {
154       exe_ctx.SetThreadSP(process->GetThreadList().GetSelectedThread());
155       thread = exe_ctx.GetThreadPtr();
156     }
157     if (thread) {
158       exe_ctx.SetFrameSP(thread->GetSelectedFrame());
159     }
160   }
161 
162   // Now we're ready to call the function:
163 
164   DiagnosticManager diagnostics;
165   lldb::addr_t wrapper_struct_addr = LLDB_INVALID_ADDRESS;
166 
167   if (!m_print_object_caller_up) {
168     Status error;
169     m_print_object_caller_up.reset(
170         exe_scope->CalculateTarget()->GetFunctionCallerForLanguage(
171             eLanguageTypeObjC, return_compiler_type, *function_address,
172             arg_value_list, "objc-object-description", error));
173     if (error.Fail()) {
174       m_print_object_caller_up.reset();
175       strm.Printf("Could not get function runner to call print for debugger "
176                   "function: %s.",
177                   error.AsCString());
178       return false;
179     }
180     m_print_object_caller_up->InsertFunction(exe_ctx, wrapper_struct_addr,
181                                              diagnostics);
182   } else {
183     m_print_object_caller_up->WriteFunctionArguments(
184         exe_ctx, wrapper_struct_addr, arg_value_list, diagnostics);
185   }
186 
187   EvaluateExpressionOptions options;
188   options.SetUnwindOnError(true);
189   options.SetTryAllThreads(true);
190   options.SetStopOthers(true);
191   options.SetIgnoreBreakpoints(true);
192   options.SetTimeout(process->GetUtilityExpressionTimeout());
193   options.SetIsForUtilityExpr(true);
194 
195   ExpressionResults results = m_print_object_caller_up->ExecuteFunction(
196       exe_ctx, &wrapper_struct_addr, options, diagnostics, ret);
197   if (results != eExpressionCompleted) {
198     strm.Printf("Error evaluating Print Object function: %d.\n", results);
199     return false;
200   }
201 
202   addr_t result_ptr = ret.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
203 
204   char buf[512];
205   size_t cstr_len = 0;
206   size_t full_buffer_len = sizeof(buf) - 1;
207   size_t curr_len = full_buffer_len;
208   while (curr_len == full_buffer_len) {
209     Status error;
210     curr_len = process->ReadCStringFromMemory(result_ptr + cstr_len, buf,
211                                               sizeof(buf), error);
212     strm.Write(buf, curr_len);
213     cstr_len += curr_len;
214   }
215   return cstr_len > 0;
216 }
217 
GetObjCModule()218 lldb::ModuleSP AppleObjCRuntime::GetObjCModule() {
219   ModuleSP module_sp(m_objc_module_wp.lock());
220   if (module_sp)
221     return module_sp;
222 
223   Process *process = GetProcess();
224   if (process) {
225     const ModuleList &modules = process->GetTarget().GetImages();
226     for (uint32_t idx = 0; idx < modules.GetSize(); idx++) {
227       module_sp = modules.GetModuleAtIndex(idx);
228       if (AppleObjCRuntime::AppleIsModuleObjCLibrary(module_sp)) {
229         m_objc_module_wp = module_sp;
230         return module_sp;
231       }
232     }
233   }
234   return ModuleSP();
235 }
236 
GetPrintForDebuggerAddr()237 Address *AppleObjCRuntime::GetPrintForDebuggerAddr() {
238   if (!m_PrintForDebugger_addr) {
239     const ModuleList &modules = m_process->GetTarget().GetImages();
240 
241     SymbolContextList contexts;
242     SymbolContext context;
243 
244     modules.FindSymbolsWithNameAndType(ConstString("_NSPrintForDebugger"),
245                                         eSymbolTypeCode, contexts);
246     if (contexts.IsEmpty()) {
247       modules.FindSymbolsWithNameAndType(ConstString("_CFPrintForDebugger"),
248                                          eSymbolTypeCode, contexts);
249       if (contexts.IsEmpty())
250         return nullptr;
251     }
252 
253     contexts.GetContextAtIndex(0, context);
254 
255     m_PrintForDebugger_addr =
256         std::make_unique<Address>(context.symbol->GetAddress());
257   }
258 
259   return m_PrintForDebugger_addr.get();
260 }
261 
CouldHaveDynamicValue(ValueObject & in_value)262 bool AppleObjCRuntime::CouldHaveDynamicValue(ValueObject &in_value) {
263   return in_value.GetCompilerType().IsPossibleDynamicType(
264       nullptr,
265       false, // do not check C++
266       true); // check ObjC
267 }
268 
GetDynamicTypeAndAddress(ValueObject & in_value,lldb::DynamicValueType use_dynamic,TypeAndOrName & class_type_or_name,Address & address,Value::ValueType & value_type)269 bool AppleObjCRuntime::GetDynamicTypeAndAddress(
270     ValueObject &in_value, lldb::DynamicValueType use_dynamic,
271     TypeAndOrName &class_type_or_name, Address &address,
272     Value::ValueType &value_type) {
273   return false;
274 }
275 
276 TypeAndOrName
FixUpDynamicType(const TypeAndOrName & type_and_or_name,ValueObject & static_value)277 AppleObjCRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name,
278                                    ValueObject &static_value) {
279   CompilerType static_type(static_value.GetCompilerType());
280   Flags static_type_flags(static_type.GetTypeInfo());
281 
282   TypeAndOrName ret(type_and_or_name);
283   if (type_and_or_name.HasType()) {
284     // The type will always be the type of the dynamic object.  If our parent's
285     // type was a pointer, then our type should be a pointer to the type of the
286     // dynamic object.  If a reference, then the original type should be
287     // okay...
288     CompilerType orig_type = type_and_or_name.GetCompilerType();
289     CompilerType corrected_type = orig_type;
290     if (static_type_flags.AllSet(eTypeIsPointer))
291       corrected_type = orig_type.GetPointerType();
292     ret.SetCompilerType(corrected_type);
293   } else {
294     // If we are here we need to adjust our dynamic type name to include the
295     // correct & or * symbol
296     std::string corrected_name(type_and_or_name.GetName().GetCString());
297     if (static_type_flags.AllSet(eTypeIsPointer))
298       corrected_name.append(" *");
299     // the parent type should be a correctly pointer'ed or referenc'ed type
300     ret.SetCompilerType(static_type);
301     ret.SetName(corrected_name.c_str());
302   }
303   return ret;
304 }
305 
AppleIsModuleObjCLibrary(const ModuleSP & module_sp)306 bool AppleObjCRuntime::AppleIsModuleObjCLibrary(const ModuleSP &module_sp) {
307   if (module_sp) {
308     const FileSpec &module_file_spec = module_sp->GetFileSpec();
309     static ConstString ObjCName("libobjc.A.dylib");
310 
311     if (module_file_spec) {
312       if (module_file_spec.GetFilename() == ObjCName)
313         return true;
314     }
315   }
316   return false;
317 }
318 
319 // we use the version of Foundation to make assumptions about the ObjC runtime
320 // on a target
GetFoundationVersion()321 uint32_t AppleObjCRuntime::GetFoundationVersion() {
322   if (!m_Foundation_major) {
323     const ModuleList &modules = m_process->GetTarget().GetImages();
324     for (uint32_t idx = 0; idx < modules.GetSize(); idx++) {
325       lldb::ModuleSP module_sp = modules.GetModuleAtIndex(idx);
326       if (!module_sp)
327         continue;
328       if (strcmp(module_sp->GetFileSpec().GetFilename().AsCString(""),
329                  "Foundation") == 0) {
330         m_Foundation_major = module_sp->GetVersion().getMajor();
331         return *m_Foundation_major;
332       }
333     }
334     return LLDB_INVALID_MODULE_VERSION;
335   } else
336     return *m_Foundation_major;
337 }
338 
GetValuesForGlobalCFBooleans(lldb::addr_t & cf_true,lldb::addr_t & cf_false)339 void AppleObjCRuntime::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
340                                                     lldb::addr_t &cf_false) {
341   cf_true = cf_false = LLDB_INVALID_ADDRESS;
342 }
343 
IsModuleObjCLibrary(const ModuleSP & module_sp)344 bool AppleObjCRuntime::IsModuleObjCLibrary(const ModuleSP &module_sp) {
345   return AppleIsModuleObjCLibrary(module_sp);
346 }
347 
ReadObjCLibrary(const ModuleSP & module_sp)348 bool AppleObjCRuntime::ReadObjCLibrary(const ModuleSP &module_sp) {
349   // Maybe check here and if we have a handler already, and the UUID of this
350   // module is the same as the one in the current module, then we don't have to
351   // reread it?
352   m_objc_trampoline_handler_up = std::make_unique<AppleObjCTrampolineHandler>(
353       m_process->shared_from_this(), module_sp);
354   if (m_objc_trampoline_handler_up != nullptr) {
355     m_read_objc_library = true;
356     return true;
357   } else
358     return false;
359 }
360 
GetStepThroughTrampolinePlan(Thread & thread,bool stop_others)361 ThreadPlanSP AppleObjCRuntime::GetStepThroughTrampolinePlan(Thread &thread,
362                                                             bool stop_others) {
363   ThreadPlanSP thread_plan_sp;
364   if (m_objc_trampoline_handler_up)
365     thread_plan_sp = m_objc_trampoline_handler_up->GetStepThroughDispatchPlan(
366         thread, stop_others);
367   return thread_plan_sp;
368 }
369 
370 // Static Functions
371 ObjCLanguageRuntime::ObjCRuntimeVersions
GetObjCVersion(Process * process,ModuleSP & objc_module_sp)372 AppleObjCRuntime::GetObjCVersion(Process *process, ModuleSP &objc_module_sp) {
373   if (!process)
374     return ObjCRuntimeVersions::eObjC_VersionUnknown;
375 
376   Target &target = process->GetTarget();
377   if (target.GetArchitecture().GetTriple().getVendor() !=
378       llvm::Triple::VendorType::Apple)
379     return ObjCRuntimeVersions::eObjC_VersionUnknown;
380 
381   for (ModuleSP module_sp : target.GetImages().Modules()) {
382     // One tricky bit here is that we might get called as part of the initial
383     // module loading, but before all the pre-run libraries get winnowed from
384     // the module list.  So there might actually be an old and incorrect ObjC
385     // library sitting around in the list, and we don't want to look at that.
386     // That's why we call IsLoadedInTarget.
387 
388     if (AppleIsModuleObjCLibrary(module_sp) &&
389         module_sp->IsLoadedInTarget(&target)) {
390       objc_module_sp = module_sp;
391       ObjectFile *ofile = module_sp->GetObjectFile();
392       if (!ofile)
393         return ObjCRuntimeVersions::eObjC_VersionUnknown;
394 
395       SectionList *sections = module_sp->GetSectionList();
396       if (!sections)
397         return ObjCRuntimeVersions::eObjC_VersionUnknown;
398       SectionSP v1_telltale_section_sp =
399           sections->FindSectionByName(ConstString("__OBJC"));
400       if (v1_telltale_section_sp) {
401         return ObjCRuntimeVersions::eAppleObjC_V1;
402       }
403       return ObjCRuntimeVersions::eAppleObjC_V2;
404     }
405   }
406 
407   return ObjCRuntimeVersions::eObjC_VersionUnknown;
408 }
409 
SetExceptionBreakpoints()410 void AppleObjCRuntime::SetExceptionBreakpoints() {
411   const bool catch_bp = false;
412   const bool throw_bp = true;
413   const bool is_internal = true;
414 
415   if (!m_objc_exception_bp_sp) {
416     m_objc_exception_bp_sp = LanguageRuntime::CreateExceptionBreakpoint(
417         m_process->GetTarget(), GetLanguageType(), catch_bp, throw_bp,
418         is_internal);
419     if (m_objc_exception_bp_sp)
420       m_objc_exception_bp_sp->SetBreakpointKind("ObjC exception");
421   } else
422     m_objc_exception_bp_sp->SetEnabled(true);
423 }
424 
ClearExceptionBreakpoints()425 void AppleObjCRuntime::ClearExceptionBreakpoints() {
426   if (!m_process)
427     return;
428 
429   if (m_objc_exception_bp_sp.get()) {
430     m_objc_exception_bp_sp->SetEnabled(false);
431   }
432 }
433 
ExceptionBreakpointsAreSet()434 bool AppleObjCRuntime::ExceptionBreakpointsAreSet() {
435   return m_objc_exception_bp_sp && m_objc_exception_bp_sp->IsEnabled();
436 }
437 
ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason)438 bool AppleObjCRuntime::ExceptionBreakpointsExplainStop(
439     lldb::StopInfoSP stop_reason) {
440   if (!m_process)
441     return false;
442 
443   if (!stop_reason || stop_reason->GetStopReason() != eStopReasonBreakpoint)
444     return false;
445 
446   uint64_t break_site_id = stop_reason->GetValue();
447   return m_process->GetBreakpointSiteList().BreakpointSiteContainsBreakpoint(
448       break_site_id, m_objc_exception_bp_sp->GetID());
449 }
450 
CalculateHasNewLiteralsAndIndexing()451 bool AppleObjCRuntime::CalculateHasNewLiteralsAndIndexing() {
452   if (!m_process)
453     return false;
454 
455   Target &target(m_process->GetTarget());
456 
457   static ConstString s_method_signature(
458       "-[NSDictionary objectForKeyedSubscript:]");
459   static ConstString s_arclite_method_signature(
460       "__arclite_objectForKeyedSubscript");
461 
462   SymbolContextList sc_list;
463 
464   target.GetImages().FindSymbolsWithNameAndType(s_method_signature,
465                                                 eSymbolTypeCode, sc_list);
466   if (sc_list.IsEmpty())
467     target.GetImages().FindSymbolsWithNameAndType(s_arclite_method_signature,
468                                                   eSymbolTypeCode, sc_list);
469   return !sc_list.IsEmpty();
470 }
471 
CreateExceptionSearchFilter()472 lldb::SearchFilterSP AppleObjCRuntime::CreateExceptionSearchFilter() {
473   Target &target = m_process->GetTarget();
474 
475   FileSpecList filter_modules;
476   if (target.GetArchitecture().GetTriple().getVendor() == llvm::Triple::Apple) {
477     filter_modules.Append(std::get<0>(GetExceptionThrowLocation()));
478   }
479   return target.GetSearchFilterForModuleList(&filter_modules);
480 }
481 
GetExceptionObjectForThread(ThreadSP thread_sp)482 ValueObjectSP AppleObjCRuntime::GetExceptionObjectForThread(
483     ThreadSP thread_sp) {
484   auto *cpp_runtime = m_process->GetLanguageRuntime(eLanguageTypeC_plus_plus);
485   if (!cpp_runtime) return ValueObjectSP();
486   auto cpp_exception = cpp_runtime->GetExceptionObjectForThread(thread_sp);
487   if (!cpp_exception) return ValueObjectSP();
488 
489   auto descriptor = GetClassDescriptor(*cpp_exception);
490   if (!descriptor || !descriptor->IsValid()) return ValueObjectSP();
491 
492   while (descriptor) {
493     ConstString class_name(descriptor->GetClassName());
494     if (class_name == "NSException")
495       return cpp_exception;
496     descriptor = descriptor->GetSuperclass();
497   }
498 
499   return ValueObjectSP();
500 }
501 
502 /// Utility method for error handling in GetBacktraceThreadFromException.
503 /// \param msg The message to add to the log.
504 /// \return An invalid ThreadSP to be returned from
505 ///         GetBacktraceThreadFromException.
506 LLVM_NODISCARD
FailExceptionParsing(llvm::StringRef msg)507 static ThreadSP FailExceptionParsing(llvm::StringRef msg) {
508   Log *log = GetLog(LLDBLog::Language);
509   LLDB_LOG(log, "Failed getting backtrace from exception: {0}", msg);
510   return ThreadSP();
511 }
512 
GetBacktraceThreadFromException(lldb::ValueObjectSP exception_sp)513 ThreadSP AppleObjCRuntime::GetBacktraceThreadFromException(
514     lldb::ValueObjectSP exception_sp) {
515   ValueObjectSP reserved_dict =
516       exception_sp->GetChildMemberWithName(ConstString("reserved"), true);
517   if (!reserved_dict)
518     return FailExceptionParsing("Failed to get 'reserved' member.");
519 
520   reserved_dict = reserved_dict->GetSyntheticValue();
521   if (!reserved_dict)
522     return FailExceptionParsing("Failed to get synthetic value.");
523 
524   TypeSystemClang *clang_ast_context =
525       ScratchTypeSystemClang::GetForTarget(*exception_sp->GetTargetSP());
526   if (!clang_ast_context)
527     return FailExceptionParsing("Failed to get scratch AST.");
528   CompilerType objc_id =
529       clang_ast_context->GetBasicType(lldb::eBasicTypeObjCID);
530   ValueObjectSP return_addresses;
531 
532   auto objc_object_from_address = [&exception_sp, &objc_id](uint64_t addr,
533                                                             const char *name) {
534     Value value(addr);
535     value.SetCompilerType(objc_id);
536     auto object = ValueObjectConstResult::Create(
537         exception_sp->GetTargetSP().get(), value, ConstString(name));
538     object = object->GetDynamicValue(eDynamicDontRunTarget);
539     return object;
540   };
541 
542   for (size_t idx = 0; idx < reserved_dict->GetNumChildren(); idx++) {
543     ValueObjectSP dict_entry = reserved_dict->GetChildAtIndex(idx, true);
544 
545     DataExtractor data;
546     data.SetAddressByteSize(dict_entry->GetProcessSP()->GetAddressByteSize());
547     Status error;
548     dict_entry->GetData(data, error);
549     if (error.Fail()) return ThreadSP();
550 
551     lldb::offset_t data_offset = 0;
552     auto dict_entry_key = data.GetAddress(&data_offset);
553     auto dict_entry_value = data.GetAddress(&data_offset);
554 
555     auto key_nsstring = objc_object_from_address(dict_entry_key, "key");
556     StreamString key_summary;
557     if (lldb_private::formatters::NSStringSummaryProvider(
558             *key_nsstring, key_summary, TypeSummaryOptions()) &&
559         !key_summary.Empty()) {
560       if (key_summary.GetString() == "\"callStackReturnAddresses\"") {
561         return_addresses = objc_object_from_address(dict_entry_value,
562                                                     "callStackReturnAddresses");
563         break;
564       }
565     }
566   }
567 
568   if (!return_addresses)
569     return FailExceptionParsing("Failed to get return addresses.");
570   auto frames_value =
571       return_addresses->GetChildMemberWithName(ConstString("_frames"), true);
572   if (!frames_value)
573     return FailExceptionParsing("Failed to get frames_value.");
574   addr_t frames_addr = frames_value->GetValueAsUnsigned(0);
575   auto count_value =
576       return_addresses->GetChildMemberWithName(ConstString("_cnt"), true);
577   if (!count_value)
578     return FailExceptionParsing("Failed to get count_value.");
579   size_t count = count_value->GetValueAsUnsigned(0);
580   auto ignore_value =
581       return_addresses->GetChildMemberWithName(ConstString("_ignore"), true);
582   if (!ignore_value)
583     return FailExceptionParsing("Failed to get ignore_value.");
584   size_t ignore = ignore_value->GetValueAsUnsigned(0);
585 
586   size_t ptr_size = m_process->GetAddressByteSize();
587   std::vector<lldb::addr_t> pcs;
588   for (size_t idx = 0; idx < count; idx++) {
589     Status error;
590     addr_t pc = m_process->ReadPointerFromMemory(
591         frames_addr + (ignore + idx) * ptr_size, error);
592     pcs.push_back(pc);
593   }
594 
595   if (pcs.empty())
596     return FailExceptionParsing("Failed to get PC list.");
597 
598   ThreadSP new_thread_sp(new HistoryThread(*m_process, 0, pcs));
599   m_process->GetExtendedThreadList().AddThread(new_thread_sp);
600   return new_thread_sp;
601 }
602 
603 std::tuple<FileSpec, ConstString>
GetExceptionThrowLocation()604 AppleObjCRuntime::GetExceptionThrowLocation() {
605   return std::make_tuple(
606       FileSpec("libobjc.A.dylib"), ConstString("objc_exception_throw"));
607 }
608 
ReadObjCLibraryIfNeeded(const ModuleList & module_list)609 void AppleObjCRuntime::ReadObjCLibraryIfNeeded(const ModuleList &module_list) {
610   if (!HasReadObjCLibrary()) {
611     std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
612 
613     size_t num_modules = module_list.GetSize();
614     for (size_t i = 0; i < num_modules; i++) {
615       auto mod = module_list.GetModuleAtIndex(i);
616       if (IsModuleObjCLibrary(mod)) {
617         ReadObjCLibrary(mod);
618         break;
619       }
620     }
621   }
622 }
623 
ModulesDidLoad(const ModuleList & module_list)624 void AppleObjCRuntime::ModulesDidLoad(const ModuleList &module_list) {
625   ReadObjCLibraryIfNeeded(module_list);
626 }
627