lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

   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 }