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
46using namespace lldb;
47using namespace lldb_private;
48
49LLDB_PLUGIN_DEFINE(AppleObjCRuntime)
50
51char AppleObjCRuntime::ID = 0;
52
53AppleObjCRuntime::~AppleObjCRuntime() = default;
54
55AppleObjCRuntime::AppleObjCRuntime(Process *process)
56 : ObjCLanguageRuntime(process), m_read_objc_library(false),
57 m_objc_trampoline_handler_up(), m_Foundation_major() {
58 ReadObjCLibraryIfNeeded(module_list: process->GetTarget().GetImages());
59}
60
61void AppleObjCRuntime::Initialize() {
62 AppleObjCRuntimeV2::Initialize();
63 AppleObjCRuntimeV1::Initialize();
64}
65
66void AppleObjCRuntime::Terminate() {
67 AppleObjCRuntimeV2::Terminate();
68 AppleObjCRuntimeV1::Terminate();
69}
70
71llvm::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(Fmt: "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(scalar&: val.GetScalar()))
85 return llvm::createStringError(Fmt: "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(target_sp: valobj.GetTargetSP(), get_process: true);
95 if (!exe_ctx.HasProcessScope())
96 return llvm::createStringError(Fmt: "no process");
97 }
98 return GetObjectDescription(str, value&: val, exe_scope: exe_ctx.GetBestExecutionContextScope());
99}
100
101llvm::Error
102AppleObjCRuntime::GetObjectDescription(Stream &strm, Value &value,
103 ExecutionContextScope *exe_scope) {
104 if (!m_read_objc_library)
105 return llvm::createStringError(Fmt: "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(Fmt: "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(Fmt: "no print function");
120
121 Target *target = exe_ctx.GetTargetPtr();
122 CompilerType compiler_type = value.GetCompilerType();
123 if (compiler_type) {
124 if (!TypeSystemClang::IsObjCObjectPointerType(type: compiler_type))
125 return llvm::createStringError(
126 Fmt: "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&: *target);
131 if (!scratch_ts_sp)
132 return llvm::createStringError(Fmt: "no scratch type system");
133
134 CompilerType opaque_type = scratch_ts_sp->GetBasicType(type: eBasicTypeObjCID);
135 if (!opaque_type)
136 opaque_type =
137 scratch_ts_sp->GetBasicType(type: 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&: *target);
148 if (!scratch_ts_sp)
149 return llvm::createStringError(Fmt: "no scratch type system");
150
151 CompilerType return_compiler_type = scratch_ts_sp->GetCStringType(is_const: 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(select_most_relevant: 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 p: exe_scope->CalculateTarget()->GetFunctionCallerForLanguage(
176 language: eLanguageTypeObjC, return_type: return_compiler_type, function_address: *function_address,
177 arg_value_list, name: "objc-object-description", error));
178 if (error.Fail()) {
179 m_print_object_caller_up.reset();
180 return llvm::createStringError(
181 S: 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, args_addr_ref&: wrapper_struct_addr,
187 diagnostic_manager&: diagnostics);
188 } else {
189 m_print_object_caller_up->WriteFunctionArguments(
190 exe_ctx, args_addr_ref&: wrapper_struct_addr, arg_values&: arg_value_list, diagnostic_manager&: 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, args_addr_ptr: &wrapper_struct_addr, options, diagnostic_manager&: diagnostics, results&: ret);
203 if (results != eExpressionCompleted)
204 return llvm::createStringError(
205 S: "could not evaluate print object function: " + toString(e: 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(vm_addr: result_ptr + cstr_len, cstr: buf,
216 cstr_max_len: sizeof(buf), error);
217 strm.Write(src: buf, src_len: curr_len);
218 cstr_len += curr_len;
219 }
220 if (cstr_len > 0)
221 return llvm::Error::success();
222 return llvm::createStringError(Fmt: "empty object description");
223}
224
225lldb::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
244Address *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(name: ConstString("_NSPrintForDebugger"),
252 symbol_type: eSymbolTypeCode, sc_list&: contexts);
253 if (contexts.IsEmpty()) {
254 modules.FindSymbolsWithNameAndType(name: ConstString("_CFPrintForDebugger"),
255 symbol_type: eSymbolTypeCode, sc_list&: contexts);
256 if (contexts.IsEmpty())
257 return nullptr;
258 }
259
260 contexts.GetContextAtIndex(idx: 0, sc&: context);
261
262 m_PrintForDebugger_addr =
263 std::make_unique<Address>(args: context.symbol->GetAddress());
264 }
265
266 return m_PrintForDebugger_addr.get();
267}
268
269bool AppleObjCRuntime::CouldHaveDynamicValue(ValueObject &in_value) {
270 return in_value.GetCompilerType().IsPossibleDynamicType(
271 target_type: nullptr,
272 check_cplusplus: false, // do not check C++
273 check_objc: true); // check ObjC
274}
275
276bool AppleObjCRuntime::GetDynamicTypeAndAddress(
277 ValueObject &in_value, lldb::DynamicValueType use_dynamic,
278 TypeAndOrName &class_type_or_name, Address &address,
279 Value::ValueType &value_type, llvm::ArrayRef<uint8_t> &local_buffer) {
280 return false;
281}
282
283TypeAndOrName
284AppleObjCRuntime::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(mask: 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(mask: eTypeIsPointer))
305 corrected_name.append(s: " *");
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
313bool 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
328uint32_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(s1: module_sp->GetFileSpec().GetFilename().AsCString(value_if_empty: ""),
336 s2: "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
346void AppleObjCRuntime::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
347 lldb::addr_t &cf_false) {
348 cf_true = cf_false = LLDB_INVALID_ADDRESS;
349}
350
351bool AppleObjCRuntime::IsModuleObjCLibrary(const ModuleSP &module_sp) {
352 return AppleIsModuleObjCLibrary(module_sp);
353}
354
355bool 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 args: m_process->shared_from_this(), args: 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
368ThreadPlanSP 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
378ObjCLanguageRuntime::ObjCRuntimeVersions
379AppleObjCRuntime::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: &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(section_dstr: 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
417void 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 target&: m_process->GetTarget(), language: 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
432void 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
441bool AppleObjCRuntime::ExceptionBreakpointsAreSet() {
442 return m_objc_exception_bp_sp && m_objc_exception_bp_sp->IsEnabled();
443}
444
445bool 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, bp_id: m_objc_exception_bp_sp->GetID());
456}
457
458bool 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(name: s_method_signature,
472 symbol_type: eSymbolTypeCode, sc_list);
473 if (sc_list.IsEmpty())
474 target.GetImages().FindSymbolsWithNameAndType(name: s_arclite_method_signature,
475 symbol_type: eSymbolTypeCode, sc_list);
476 return !sc_list.IsEmpty();
477}
478
479lldb::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(file: std::get<0>(t: GetExceptionThrowLocation()));
485 }
486 return target.GetSearchFilterForModuleList(containingModuleList: &filter_modules);
487}
488
489ValueObjectSP AppleObjCRuntime::GetExceptionObjectForThread(
490 ThreadSP thread_sp) {
491 auto *cpp_runtime = m_process->GetLanguageRuntime(language: 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(in_value&: *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]]
514static ThreadSP FailExceptionParsing(llvm::StringRef msg) {
515 Log *log = GetLog(mask: LLDBLog::Language);
516 LLDB_LOG(log, "Failed getting backtrace from exception: {0}", msg);
517 return ThreadSP();
518}
519
520ThreadSP AppleObjCRuntime::GetBacktraceThreadFromException(
521 lldb::ValueObjectSP exception_sp) {
522 ValueObjectSP reserved_dict =
523 exception_sp->GetChildMemberWithName(name: "reserved");
524 if (!reserved_dict)
525 return FailExceptionParsing(msg: "Failed to get 'reserved' member.");
526
527 reserved_dict = reserved_dict->GetSyntheticValue();
528 if (!reserved_dict)
529 return FailExceptionParsing(msg: "Failed to get synthetic value.");
530
531 TypeSystemClangSP scratch_ts_sp =
532 ScratchTypeSystemClang::GetForTarget(target&: *exception_sp->GetTargetSP());
533 if (!scratch_ts_sp)
534 return FailExceptionParsing(msg: "Failed to get scratch AST.");
535 CompilerType objc_id = scratch_ts_sp->GetBasicType(type: 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 exe_scope: exception_sp->GetTargetSP().get(), value, name: ConstString(name));
544 object = object->GetDynamicValue(valueType: 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(offset_ptr: &data_offset);
560 auto dict_entry_value = data.GetAddress(offset_ptr: &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 valobj&: *key_nsstring, stream&: key_summary, options: 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(msg: "Failed to get return addresses.");
577 auto frames_value = return_addresses->GetChildMemberWithName(name: "_frames");
578 if (!frames_value)
579 return FailExceptionParsing(msg: "Failed to get frames_value.");
580 addr_t frames_addr = frames_value->GetValueAsUnsigned(fail_value: 0);
581 auto count_value = return_addresses->GetChildMemberWithName(name: "_cnt");
582 if (!count_value)
583 return FailExceptionParsing(msg: "Failed to get count_value.");
584 size_t count = count_value->GetValueAsUnsigned(fail_value: 0);
585 auto ignore_value = return_addresses->GetChildMemberWithName(name: "_ignore");
586 if (!ignore_value)
587 return FailExceptionParsing(msg: "Failed to get ignore_value.");
588 size_t ignore = ignore_value->GetValueAsUnsigned(fail_value: 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 vm_addr: frames_addr + (ignore + idx) * ptr_size, error);
596 pcs.push_back(x: pc);
597 }
598
599 if (pcs.empty())
600 return FailExceptionParsing(msg: "Failed to get PC list.");
601
602 ThreadSP new_thread_sp(new HistoryThread(*m_process, 0, pcs));
603 m_process->GetExtendedThreadList().AddThread(thread_sp: new_thread_sp);
604 return new_thread_sp;
605}
606
607std::tuple<FileSpec, ConstString>
608AppleObjCRuntime::GetExceptionThrowLocation() {
609 return std::make_tuple(
610 args: FileSpec("libobjc.A.dylib"), args: ConstString("objc_exception_throw"));
611}
612
613void 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(idx: i);
620 if (IsModuleObjCLibrary(module_sp: mod)) {
621 ReadObjCLibrary(module_sp: mod);
622 break;
623 }
624 }
625 }
626}
627
628void AppleObjCRuntime::ModulesDidLoad(const ModuleList &module_list) {
629 ReadObjCLibraryIfNeeded(module_list);
630}
631

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