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
23
24namespace lldb_private {
25
27public:
28 ~AppleObjCRuntimeV2() override = default;
29
30 static void Initialize();
31
32 static void Terminate();
33
35 CreateInstance(Process *process, lldb::LanguageType language);
36
37 static llvm::StringRef GetPluginNameStatic() { return "apple-objc-v2"; }
38
39 static char ID;
40
41 bool isA(const void *ClassID) const override {
42 return ClassID == &ID || AppleObjCRuntime::isA(ClassID);
43 }
44
45 static bool classof(const LanguageRuntime *runtime) {
46 return runtime->isA(&ID);
47 }
48
50 lldb::DynamicValueType use_dynamic,
51 TypeAndOrName &class_type_or_name,
52 Address &address,
53 Value::ValueType &value_type) override;
54
55 llvm::Expected<std::unique_ptr<UtilityFunction>>
56 CreateObjectChecker(std::string name, ExecutionContext &exe_ctx) override;
57
58 llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
59
62 }
63
64 size_t GetByteOffsetForIvar(CompilerType &parent_qual_type,
65 const char *ivar_name) override;
66
68
70
72
73 DeclVendor *GetDeclVendor() override;
74
76
78
79 bool IsTaggedPointer(lldb::addr_t ptr) override;
80
82 return m_tagged_pointer_vendor_up.get();
83 }
84
86
87 /// Returns the base address for relative method list selector strings.
90 }
91
92 void SetRelativeSelectorBaseAddr(lldb::addr_t relative_selector_base) {
93 m_relative_selector_base = relative_selector_base;
94 }
95
97 lldb::addr_t &cf_false) override;
98
99 // none of these are valid ISAs - we use them to infer the type
100 // of tagged pointers - if we have something meaningful to say
101 // we report an actual type - otherwise, we just say tagged
102 // there is no connection between the values here and the tagged pointers map
108 5;
110
111protected:
112 lldb::BreakpointResolverSP
113 CreateExceptionResolver(const lldb::BreakpointSP &bkpt, bool catch_bp,
114 bool throw_bp) override;
115
116private:
118 public:
120
121 bool NeedsUpdate(Process *process, AppleObjCRuntimeV2 *runtime,
122 RemoteNXMapTable &hash_table);
123
124 void UpdateSignature(const RemoteNXMapTable &hash_table);
125
126 protected:
130 };
131
133 public:
134 static NonPointerISACache *
136 const lldb::ModuleSP &objc_module_sp);
137
139
140 private:
142 const lldb::ModuleSP &objc_module_sp,
143 uint64_t objc_debug_isa_class_mask,
144 uint64_t objc_debug_isa_magic_mask,
145 uint64_t objc_debug_isa_magic_value,
146 uint64_t objc_debug_indexed_isa_magic_mask,
147 uint64_t objc_debug_indexed_isa_magic_value,
148 uint64_t objc_debug_indexed_isa_index_mask,
149 uint64_t objc_debug_indexed_isa_index_shift,
150 lldb::addr_t objc_indexed_classes);
151
152 bool EvaluateNonPointerISA(ObjCISA isa, ObjCISA &ret_isa);
153
155 std::map<ObjCISA, ObjCLanguageRuntime::ClassDescriptorSP> m_cache;
156 lldb::ModuleWP m_objc_module_wp;
160
166
167 std::vector<lldb::addr_t> m_indexed_isa_cache;
168
169 friend class AppleObjCRuntimeV2;
170
173 };
174
177 public:
178 ~TaggedPointerVendorV2() override = default;
179
180 static TaggedPointerVendorV2 *
182 const lldb::ModuleSP &objc_module_sp);
183
184 protected:
186
188 : TaggedPointerVendor(), m_runtime(runtime) {}
189
190 private:
194 };
195
197 public:
198 bool IsPossibleTaggedPointer(lldb::addr_t ptr) override;
199
201 GetClassDescriptor(lldb::addr_t ptr) override;
202
203 protected:
205 AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask,
206 uint32_t objc_debug_taggedpointer_slot_shift,
207 uint32_t objc_debug_taggedpointer_slot_mask,
208 uint32_t objc_debug_taggedpointer_payload_lshift,
209 uint32_t objc_debug_taggedpointer_payload_rshift,
210 lldb::addr_t objc_debug_taggedpointer_classes);
211
212 typedef std::map<uint8_t, ObjCLanguageRuntime::ClassDescriptorSP> Cache;
213 typedef Cache::iterator CacheIterator;
221
223
225 const TaggedPointerVendorRuntimeAssisted &) = delete;
228 };
229
232 public:
234 GetClassDescriptor(lldb::addr_t ptr) override;
235
236 protected:
238 AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask,
239 uint64_t objc_debug_taggedpointer_ext_mask,
240 uint32_t objc_debug_taggedpointer_slot_shift,
241 uint32_t objc_debug_taggedpointer_ext_slot_shift,
242 uint32_t objc_debug_taggedpointer_slot_mask,
243 uint32_t objc_debug_taggedpointer_ext_slot_mask,
244 uint32_t objc_debug_taggedpointer_payload_lshift,
245 uint32_t objc_debug_taggedpointer_payload_rshift,
246 uint32_t objc_debug_taggedpointer_ext_payload_lshift,
247 uint32_t objc_debug_taggedpointer_ext_payload_rshift,
248 lldb::addr_t objc_debug_taggedpointer_classes,
249 lldb::addr_t objc_debug_taggedpointer_ext_classes);
250
252
253 typedef std::map<uint8_t, ObjCLanguageRuntime::ClassDescriptorSP> Cache;
254 typedef Cache::iterator CacheIterator;
262
264
268 };
269
271 public:
272 bool IsPossibleTaggedPointer(lldb::addr_t ptr) override;
273
275 GetClassDescriptor(lldb::addr_t ptr) override;
276
277 protected:
279 : TaggedPointerVendorV2(runtime) {}
280
282
286 };
287
292
293 DescriptorMapUpdateResult(bool ran, bool retry, uint32_t found) {
294 m_update_ran = ran;
295
296 m_retry_update = retry;
297
298 m_num_found = found;
299 }
300
301 static DescriptorMapUpdateResult Fail() { return {false, false, 0}; }
302
304 return {true, false, found};
305 }
306
307 static DescriptorMapUpdateResult Retry() { return {false, true, 0}; }
308 };
309
310 /// Abstraction to read the Objective-C class info.
312 public:
314 std::mutex &GetMutex() { return m_mutex; }
315
316 protected:
317 /// The lifetime of this object is tied to that of the runtime.
319 std::mutex m_mutex;
320 };
321
322 /// We can read the class info from the Objective-C runtime using
323 /// gdb_objc_realized_classes, objc_copyRealizedClassList or
324 /// objc_getRealizedClassList_trylock. The RealizedClassList variants are
325 /// preferred because they include lazily named classes, but they are not
326 /// always available or safe to call.
327 ///
328 /// We potentially need more than one helper for the same process, because we
329 /// may need to use gdb_objc_realized_classes until dyld is initialized and
330 /// then switch over to objc_copyRealizedClassList or
331 /// objc_getRealizedClassList_trylock for lazily named classes.
333 public:
335 : ClassInfoExtractor(runtime) {}
336
339
340 private:
341 enum Helper {
345 };
346
347 /// Compute which helper to use. If dyld is not yet fully initialized we
348 /// must use gdb_objc_realized_classes. Otherwise, we prefer
349 /// objc_getRealizedClassList_trylock and objc_copyRealizedClassList
350 /// respectively, depending on availability.
351 Helper ComputeHelper(ExecutionContext &exe_ctx) const;
352
354 Helper helper);
356
357 std::unique_ptr<UtilityFunction>
359 std::string code, std::string name);
360
362 std::unique_ptr<UtilityFunction> utility_function;
364 };
365
369 };
370
371 /// Abstraction to read the Objective-C class info from the shared cache.
373 public:
375 : ClassInfoExtractor(runtime) {}
376
378
379 private:
381
382 std::unique_ptr<UtilityFunction>
384
385 std::unique_ptr<UtilityFunction> m_utility_function;
387 };
388
389 AppleObjCRuntimeV2(Process *process, const lldb::ModuleSP &objc_module_sp);
390
392
394
395 /// Update the generation count of realized classes. This is not an exact
396 /// count but rather a value that is incremented when new classes are realized
397 /// or destroyed. Unlike the count in gdb_objc_realized_classes, it will
398 /// change when lazily named classes get realized.
400
402 uint32_t num_class_infos);
403
408 };
409
412
415
417
418 bool HasSymbol(ConstString Name);
419
424 return m_non_pointer_isa_cache_up.get();
425 }
426
427 friend class ClassDescriptorV2;
428
429 lldb::ModuleSP m_objc_module_sp;
430
433
434 std::unique_ptr<DeclVendor> m_decl_vendor_up;
443 std::unique_ptr<NonPointerISACache> m_non_pointer_isa_cache_up;
444 std::unique_ptr<TaggedPointerVendor> m_tagged_pointer_vendor_up;
448 std::optional<std::pair<lldb::addr_t, lldb::addr_t>> m_CFBoolean_values;
450};
451
452} // namespace lldb_private
453
454#endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCRUNTIMEV2_H
A section + offset based address class.
Definition: Address.h:59
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)
NonPointerISACache(AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp, uint64_t objc_debug_isa_class_mask, uint64_t objc_debug_isa_magic_mask, uint64_t objc_debug_isa_magic_value, uint64_t objc_debug_indexed_isa_magic_mask, uint64_t objc_debug_indexed_isa_magic_value, uint64_t objc_debug_indexed_isa_index_mask, uint64_t objc_debug_indexed_isa_index_shift, lldb::addr_t objc_indexed_classes)
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)
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
static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSNumber
NonPointerISACache * GetNonPointerIsaCache()
static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSDate
size_t GetByteOffsetForIvar(CompilerType &parent_qual_type, const char *ivar_name) override
SharedCacheClassInfoExtractor m_shared_cache_class_info_extractor
DynamicClassInfoExtractor m_dynamic_class_info_extractor
static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSAtom
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
ClassDescriptorSP GetClassDescriptor(ValueObject &in_value) override
bool isA(const void *ClassID) const override
lldb::addr_t LookupRuntimeSymbol(ConstString name) override
static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSDateTS
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
static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSManagedObject
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
static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA
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:39
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
std::shared_ptr< ClassDescriptor > ClassDescriptorSP
std::shared_ptr< EncodingToType > EncodingToTypeSP
A plug-in interface definition class for debugging a process.
Definition: Process.h:342
Sometimes you can find the name of the type corresponding to an object, but we don't have debug infor...
Definition: Type.h:410
"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:74
A class that represents a running process on the host machine.
LanguageType
Programming language type.
uint64_t addr_t
Definition: lldb-types.h:83
static DescriptorMapUpdateResult Success(uint32_t found)
DescriptorMapUpdateResult(bool ran, bool retry, uint32_t found)