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