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