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 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 60 void AppleObjCRuntime::Initialize() { 61 AppleObjCRuntimeV2::Initialize(); 62 AppleObjCRuntimeV1::Initialize(); 63 } 64 65 void AppleObjCRuntime::Terminate() { 66 AppleObjCRuntimeV2::Terminate(); 67 AppleObjCRuntimeV1::Terminate(); 68 } 69 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 } 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 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 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 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 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 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 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 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 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 344 bool AppleObjCRuntime::IsModuleObjCLibrary(const ModuleSP &module_sp) { 345 return AppleIsModuleObjCLibrary(module_sp); 346 } 347 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 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 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 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 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 434 bool AppleObjCRuntime::ExceptionBreakpointsAreSet() { 435 return m_objc_exception_bp_sp && m_objc_exception_bp_sp->IsEnabled(); 436 } 437 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 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 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 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 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 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> 604 AppleObjCRuntime::GetExceptionThrowLocation() { 605 return std::make_tuple( 606 FileSpec("libobjc.A.dylib"), ConstString("objc_exception_throw")); 607 } 608 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 624 void AppleObjCRuntime::ModulesDidLoad(const ModuleList &module_list) { 625 ReadObjCLibraryIfNeeded(module_list); 626 } 627