LLDB mainline
AppleObjCRuntimeV2.h
Go to the documentation of this file.
1//===-- AppleObjCRuntimeV2.h ------------------------------------*- C++ -*-===//
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#ifndef LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCRUNTIMEV2_H
10#define LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCRUNTIMEV2_H
11
12#include <map>
13#include <memory>
14#include <mutex>
15#include <optional>
16
17#include "AppleObjCRuntime.h"
18#include "lldb/lldb-private.h"
19
21
22#include "llvm/ADT/BitVector.h"
23
25
26namespace lldb_private {
27
29public:
30 ~AppleObjCRuntimeV2() override = default;
31
32 static void Initialize();
33
34 static void Terminate();
35
37 CreateInstance(Process *process, lldb::LanguageType language);
38
39 static llvm::StringRef GetPluginNameStatic() { return "apple-objc-v2"; }
40
42
43 static char ID;
44
45 bool isA(const void *ClassID) const override {
46 return ClassID == &ID || AppleObjCRuntime::isA(ClassID);
47 }
48
49 static bool classof(const LanguageRuntime *runtime) {
50 return runtime->isA(&ID);
51 }
52
54 lldb::DynamicValueType use_dynamic,
55 TypeAndOrName &class_type_or_name,
56 Address &address,
57 Value::ValueType &value_type) override;
58
59 llvm::Expected<std::unique_ptr<UtilityFunction>>
60 CreateObjectChecker(std::string name, ExecutionContext &exe_ctx) override;
61
62 llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
63
66 }
67
68 size_t GetByteOffsetForIvar(CompilerType &parent_ast_type,
69 const char *ivar_name) override;
70
72
74
76
77 DeclVendor *GetDeclVendor() override;
78
80
82
83 bool IsTaggedPointer(lldb::addr_t ptr) override;
84
86 return m_tagged_pointer_vendor_up.get();
87 }
88
90
91 /// Returns the base address for relative method list selector strings.
94 }
95
96 void SetRelativeSelectorBaseAddr(lldb::addr_t relative_selector_base) {
97 m_relative_selector_base = relative_selector_base;
98 }
99
101 lldb::addr_t &cf_false) override;
102
103 void ModulesDidLoad(const ModuleList &module_list) override;
104
105 bool IsSharedCacheImageLoaded(uint16_t image_index);
106
107 std::optional<uint64_t> GetSharedCacheImageHeaderVersion();
108
109protected:
111 CreateExceptionResolver(const lldb::BreakpointSP &bkpt, bool catch_bp,
112 bool throw_bp) override;
113
114private:
116 public:
118
119 bool NeedsUpdate(Process *process, AppleObjCRuntimeV2 *runtime,
120 RemoteNXMapTable &hash_table);
121
122 void UpdateSignature(const RemoteNXMapTable &hash_table);
123
124 protected:
125 uint32_t m_count = 0;
126 uint32_t m_num_buckets = 0;
128 };
129
131 public:
132 static NonPointerISACache *
134 const lldb::ModuleSP &objc_module_sp);
135
137
138 private:
140 const lldb::ModuleSP &objc_module_sp,
141 uint64_t objc_debug_isa_class_mask,
142 uint64_t objc_debug_isa_magic_mask,
143 uint64_t objc_debug_isa_magic_value,
144 uint64_t objc_debug_indexed_isa_magic_mask,
145 uint64_t objc_debug_indexed_isa_magic_value,
146 uint64_t objc_debug_indexed_isa_index_mask,
147 uint64_t objc_debug_indexed_isa_index_shift,
148 lldb::addr_t objc_indexed_classes);
149
150 bool EvaluateNonPointerISA(ObjCISA isa, ObjCISA &ret_isa);
151
153 std::map<ObjCISA, ObjCLanguageRuntime::ClassDescriptorSP> m_cache;
158
164
165 std::vector<lldb::addr_t> m_indexed_isa_cache;
166
167 friend class AppleObjCRuntimeV2;
168
171 };
172
175 public:
176 ~TaggedPointerVendorV2() override = default;
177
178 static TaggedPointerVendorV2 *
180 const lldb::ModuleSP &objc_module_sp);
181
182 protected:
184
186 : TaggedPointerVendor(), m_runtime(runtime) {}
187
188 private:
192 };
193
195 public:
196 bool IsPossibleTaggedPointer(lldb::addr_t ptr) override;
197
199 GetClassDescriptor(lldb::addr_t ptr) override;
200
201 protected:
203 AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask,
204 uint32_t objc_debug_taggedpointer_slot_shift,
205 uint32_t objc_debug_taggedpointer_slot_mask,
206 uint32_t objc_debug_taggedpointer_payload_lshift,
207 uint32_t objc_debug_taggedpointer_payload_rshift,
208 lldb::addr_t objc_debug_taggedpointer_classes);
209
210 typedef std::map<uint8_t, ObjCLanguageRuntime::ClassDescriptorSP> Cache;
211 typedef Cache::iterator CacheIterator;
219
221
223 const TaggedPointerVendorRuntimeAssisted &) = delete;
226 };
227
230 public:
232 GetClassDescriptor(lldb::addr_t ptr) override;
233
234 protected:
236 AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask,
237 uint64_t objc_debug_taggedpointer_ext_mask,
238 uint32_t objc_debug_taggedpointer_slot_shift,
239 uint32_t objc_debug_taggedpointer_ext_slot_shift,
240 uint32_t objc_debug_taggedpointer_slot_mask,
241 uint32_t objc_debug_taggedpointer_ext_slot_mask,
242 uint32_t objc_debug_taggedpointer_payload_lshift,
243 uint32_t objc_debug_taggedpointer_payload_rshift,
244 uint32_t objc_debug_taggedpointer_ext_payload_lshift,
245 uint32_t objc_debug_taggedpointer_ext_payload_rshift,
246 lldb::addr_t objc_debug_taggedpointer_classes,
247 lldb::addr_t objc_debug_taggedpointer_ext_classes);
248
250
251 typedef std::map<uint8_t, ObjCLanguageRuntime::ClassDescriptorSP> Cache;
252 typedef Cache::iterator CacheIterator;
260
262
266 };
267
269 public:
270 bool IsPossibleTaggedPointer(lldb::addr_t ptr) override;
271
273 GetClassDescriptor(lldb::addr_t ptr) override;
274
275 protected:
277 : TaggedPointerVendorV2(runtime) {}
278
280
284 };
285
289 uint32_t m_num_found;
290
291 DescriptorMapUpdateResult(bool ran, bool retry, uint32_t found) {
292 m_update_ran = ran;
293
294 m_retry_update = retry;
295
296 m_num_found = found;
297 }
298
299 static DescriptorMapUpdateResult Fail() { return {false, false, 0}; }
300
301 static DescriptorMapUpdateResult Success(uint32_t found) {
302 return {true, false, found};
303 }
304
305 static DescriptorMapUpdateResult Retry() { return {false, true, 0}; }
306 };
307
308 /// Abstraction to read the Objective-C class info.
310 public:
312 std::mutex &GetMutex() { return m_mutex; }
313
314 protected:
315 /// The lifetime of this object is tied to that of the runtime.
317 std::mutex m_mutex;
318 };
319
320 /// We can read the class info from the Objective-C runtime using
321 /// gdb_objc_realized_classes, objc_copyRealizedClassList or
322 /// objc_getRealizedClassList_trylock. The RealizedClassList variants are
323 /// preferred because they include lazily named classes, but they are not
324 /// always available or safe to call.
325 ///
326 /// We potentially need more than one helper for the same process, because we
327 /// may need to use gdb_objc_realized_classes until dyld is initialized and
328 /// then switch over to objc_copyRealizedClassList or
329 /// objc_getRealizedClassList_trylock for lazily named classes.
331 public:
333 : ClassInfoExtractor(runtime) {}
334
337
338 private:
339 enum Helper {
343 };
344
345 /// Compute which helper to use. If dyld is not yet fully initialized we
346 /// must use gdb_objc_realized_classes. Otherwise, we prefer
347 /// objc_getRealizedClassList_trylock and objc_copyRealizedClassList
348 /// respectively, depending on availability.
349 Helper ComputeHelper(ExecutionContext &exe_ctx) const;
350
352 Helper helper);
354
355 std::unique_ptr<UtilityFunction>
357 std::string code, std::string name);
358
360 std::unique_ptr<UtilityFunction> utility_function;
362 };
363
367 };
368
369 /// Abstraction to read the Objective-C class info from the shared cache.
371 public:
373 : ClassInfoExtractor(runtime) {}
374
376
377 private:
379
380 std::unique_ptr<UtilityFunction>
382
383 std::unique_ptr<UtilityFunction> m_utility_function;
385 };
386
388 public:
389 static std::unique_ptr<SharedCacheImageHeaders>
391
393
394 bool IsImageLoaded(uint16_t image_index);
395
396 uint64_t GetVersion();
397
398 private:
400 lldb::addr_t headerInfoRWs_ptr, uint32_t count,
401 uint32_t entsize)
402 : m_runtime(runtime), m_headerInfoRWs_ptr(headerInfoRWs_ptr),
403 m_loaded_images(count, false), m_version(0), m_count(count),
404 m_entsize(entsize), m_needs_update(true) {}
405 llvm::Error UpdateIfNeeded();
406
409 llvm::BitVector m_loaded_images;
410 uint64_t m_version;
411 uint32_t m_count;
412 uint32_t m_entsize;
414 };
415
416 AppleObjCRuntimeV2(Process *process, const lldb::ModuleSP &objc_module_sp);
417
419
421
422 /// Update the generation count of realized classes. This is not an exact
423 /// count but rather a value that is incremented when new classes are realized
424 /// or destroyed. Unlike the count in gdb_objc_realized_classes, it will
425 /// change when lazily named classes get realized.
427
429 uint32_t num_class_infos);
430
435 };
436
439
442
444
445 bool HasSymbol(ConstString Name);
446
451 return m_non_pointer_isa_cache_up.get();
452 }
453
454 friend class ClassDescriptorV2;
455
457
460
461 std::unique_ptr<DeclVendor> m_decl_vendor_up;
470 std::unique_ptr<NonPointerISACache> m_non_pointer_isa_cache_up;
471 std::unique_ptr<TaggedPointerVendor> m_tagged_pointer_vendor_up;
475 std::optional<std::pair<lldb::addr_t, lldb::addr_t>> m_CFBoolean_values;
477 std::unique_ptr<SharedCacheImageHeaders> m_shared_cache_image_headers_up;
478};
479
480} // namespace lldb_private
481
482#endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCRUNTIMEV2_H
A section + offset based address class.
Definition: Address.h:62
Abstraction to read the Objective-C class info.
AppleObjCRuntimeV2 & m_runtime
The lifetime of this object is tied to that of the runtime.
We can read the class info from the Objective-C runtime using gdb_objc_realized_classes,...
UtilityFunction * GetClassInfoUtilityFunction(ExecutionContext &exe_ctx, Helper helper)
Helper ComputeHelper(ExecutionContext &exe_ctx) const
Compute which helper to use.
std::unique_ptr< UtilityFunction > GetClassInfoUtilityFunctionImpl(ExecutionContext &exe_ctx, Helper helper, std::string code, std::string name)
void UpdateSignature(const RemoteNXMapTable &hash_table)
bool NeedsUpdate(Process *process, AppleObjCRuntimeV2 *runtime, RemoteNXMapTable &hash_table)
bool EvaluateNonPointerISA(ObjCISA isa, ObjCISA &ret_isa)
ObjCLanguageRuntime::ClassDescriptorSP GetClassDescriptor(ObjCISA isa)
static NonPointerISACache * CreateInstance(AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp)
NonPointerISACache(const NonPointerISACache &)=delete
const NonPointerISACache & operator=(const NonPointerISACache &)=delete
std::map< ObjCISA, ObjCLanguageRuntime::ClassDescriptorSP > m_cache
Abstraction to read the Objective-C class info from the shared cache.
UtilityFunction * GetClassInfoUtilityFunction(ExecutionContext &exe_ctx)
std::unique_ptr< UtilityFunction > GetClassInfoUtilityFunctionImpl(ExecutionContext &exe_ctx)
SharedCacheImageHeaders(AppleObjCRuntimeV2 &runtime, lldb::addr_t headerInfoRWs_ptr, uint32_t count, uint32_t entsize)
static std::unique_ptr< SharedCacheImageHeaders > CreateSharedCacheImageHeaders(AppleObjCRuntimeV2 &runtime)
ObjCLanguageRuntime::ClassDescriptorSP GetClassDescriptor(lldb::addr_t ptr) override
std::map< uint8_t, ObjCLanguageRuntime::ClassDescriptorSP > Cache
const TaggedPointerVendorExtended & operator=(const TaggedPointerVendorExtended &)=delete
TaggedPointerVendorExtended(const TaggedPointerVendorExtended &)=delete
ObjCLanguageRuntime::ClassDescriptorSP GetClassDescriptor(lldb::addr_t ptr) override
const TaggedPointerVendorLegacy & operator=(const TaggedPointerVendorLegacy &)=delete
TaggedPointerVendorLegacy(const TaggedPointerVendorLegacy &)=delete
const TaggedPointerVendorRuntimeAssisted & operator=(const TaggedPointerVendorRuntimeAssisted &)=delete
ObjCLanguageRuntime::ClassDescriptorSP GetClassDescriptor(lldb::addr_t ptr) override
TaggedPointerVendorRuntimeAssisted(const TaggedPointerVendorRuntimeAssisted &)=delete
std::map< uint8_t, ObjCLanguageRuntime::ClassDescriptorSP > Cache
TaggedPointerVendorV2(const TaggedPointerVendorV2 &)=delete
static TaggedPointerVendorV2 * CreateInstance(AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp)
const TaggedPointerVendorV2 & operator=(const TaggedPointerVendorV2 &)=delete
llvm::Expected< std::unique_ptr< UtilityFunction > > CreateObjectChecker(std::string name, ExecutionContext &exe_ctx) override
bool IsTaggedPointer(lldb::addr_t ptr) override
uint32_t ParseClassInfoArray(const lldb_private::DataExtractor &data, uint32_t num_class_infos)
bool RealizedClassGenerationCountChanged()
Update the generation count of realized classes.
void SetRelativeSelectorBaseAddr(lldb::addr_t relative_selector_base)
static llvm::StringRef GetPluginNameStatic()
EncodingToTypeSP GetEncodingToType() override
~AppleObjCRuntimeV2() override=default
TaggedPointerVendor * GetTaggedPointerVendor() override
NonPointerISACache * GetNonPointerIsaCache()
size_t GetByteOffsetForIvar(CompilerType &parent_ast_type, const char *ivar_name) override
SharedCacheClassInfoExtractor m_shared_cache_class_info_extractor
DynamicClassInfoExtractor m_dynamic_class_info_extractor
ObjCRuntimeVersions GetRuntimeVersion() const override
ClassDescriptorSP GetClassDescriptorFromISA(ObjCISA isa) override
static bool classof(const LanguageRuntime *runtime)
bool GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic, TypeAndOrName &class_type_or_name, Address &address, Value::ValueType &value_type) override
bool isA(const void *ClassID) const override
std::unique_ptr< SharedCacheImageHeaders > m_shared_cache_image_headers_up
lldb::addr_t LookupRuntimeSymbol(ConstString name) override
ClassDescriptorSP GetClassDescriptor(ValueObject &valobj) override
void ModulesDidLoad(const ModuleList &module_list) override
Called when modules have been loaded in the process.
bool IsSharedCacheImageLoaded(uint16_t image_index)
lldb::addr_t GetRelativeSelectorBaseAddr()
Returns the base address for relative method list selector strings.
std::optional< std::pair< lldb::addr_t, lldb::addr_t > > m_CFBoolean_values
llvm::StringRef GetPluginName() override
std::unique_ptr< DeclVendor > m_decl_vendor_up
std::unique_ptr< TaggedPointerVendor > m_tagged_pointer_vendor_up
std::unique_ptr< NonPointerISACache > m_non_pointer_isa_cache_up
void GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true, lldb::addr_t &cf_false) override
lldb::BreakpointResolverSP CreateExceptionResolver(const lldb::BreakpointSP &bkpt, bool catch_bp, bool throw_bp) override
LanguageRuntime * GetPreferredLanguageRuntime(ValueObject &in_value) override
Return the preferred language runtime instance, which in most cases will be the current instance.
std::optional< uint64_t > GetSharedCacheImageHeaderVersion()
void WarnIfNoClassesCached(SharedCacheWarningReason reason)
static lldb_private::LanguageRuntime * CreateInstance(Process *process, lldb::LanguageType language)
bool isA(const void *ClassID) const override
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:40
An data extractor class.
Definition: DataExtractor.h:48
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
virtual bool isA(const void *ClassID) const
A collection class for Module objects.
Definition: ModuleList.h:103
std::shared_ptr< ClassDescriptor > ClassDescriptorSP
std::shared_ptr< EncodingToType > EncodingToTypeSP
A plug-in interface definition class for debugging a process.
Definition: Process.h:341
Sometimes you can find the name of the type corresponding to an object, but we don't have debug infor...
Definition: Type.h:745
"lldb/Expression/UtilityFunction.h" Encapsulates a bit of source code that provides a function that i...
ValueType
Type that describes Value::m_value.
Definition: Value.h:41
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
A class that represents a running process on the host machine.
std::shared_ptr< lldb_private::BreakpointResolver > BreakpointResolverSP
Definition: lldb-forward.h:326
std::weak_ptr< lldb_private::Module > ModuleWP
Definition: lldb-forward.h:372
LanguageType
Programming language type.
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
Definition: lldb-forward.h:319
uint64_t addr_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:371
static DescriptorMapUpdateResult Success(uint32_t found)
DescriptorMapUpdateResult(bool ran, bool retry, uint32_t found)