lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

   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
  20 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
  21
  22 #include "llvm/ADT/BitVector.h"
  23
  24 class RemoteNXMapTable;
  25
  26 namespace lldb_private {
  27
  28 class AppleObjCRuntimeV2 : public AppleObjCRuntime {
  29 public:
  30   ~AppleObjCRuntimeV2() override = default;
  31
  32   static void Initialize();
  33
  34   static void Terminate();
  35
  36   static lldb_private::LanguageRuntime *
  37   CreateInstance(Process *process, lldb::LanguageType language);
  38
  39   static llvm::StringRef GetPluginNameStatic() { return "apple-objc-v2"; }
  40
  41   LanguageRuntime *GetPreferredLanguageRuntime(ValueObject &in_value) override;
  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
  53   bool GetDynamicTypeAndAddress(ValueObject &in_value,
  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
  64   ObjCRuntimeVersions GetRuntimeVersion() const override {
  65     return ObjCRuntimeVersions::eAppleObjC_V2;
  66   }
  67
  68   size_t GetByteOffsetForIvar(CompilerType &parent_ast_type,
  69                               const char *ivar_name) override;
  70
  71   void UpdateISAToDescriptorMapIfNeeded() override;
  72
  73   ClassDescriptorSP GetClassDescriptor(ValueObject &valobj) override;
  74
  75   ClassDescriptorSP GetClassDescriptorFromISA(ObjCISA isa) override;
  76
  77   DeclVendor *GetDeclVendor() override;
  78
  79   lldb::addr_t LookupRuntimeSymbol(ConstString name) override;
  80
  81   EncodingToTypeSP GetEncodingToType() override;
  82
  83   bool IsTaggedPointer(lldb::addr_t ptr) override;
  84
  85   TaggedPointerVendor *GetTaggedPointerVendor() override {
  86     return m_tagged_pointer_vendor_up.get();
  87   }
  88
  89   lldb::addr_t GetTaggedPointerObfuscator();
  90
  91   /// Returns the base address for relative method list selector strings.
  92   lldb::addr_t GetRelativeSelectorBaseAddr() {
  93     return m_relative_selector_base;
  94   }
  95
  96   void SetRelativeSelectorBaseAddr(lldb::addr_t relative_selector_base) {
  97     m_relative_selector_base = relative_selector_base;
  98   }
  99
 100   void GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
 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
 109   StructuredData::ObjectSP GetLanguageSpecificData(SymbolContext sc) override;
 110
 111 protected:
 112   lldb::BreakpointResolverSP
 113   CreateExceptionResolver(const lldb::BreakpointSP &bkpt, bool catch_bp,
 114                           bool throw_bp) override;
 115
 116 private:
 117   class HashTableSignature {
 118   public:
 119     HashTableSignature();
 120
 121     bool NeedsUpdate(Process *process, AppleObjCRuntimeV2 *runtime,
 122                      RemoteNXMapTable &hash_table);
 123
 124     void UpdateSignature(const RemoteNXMapTable &hash_table);
 125
 126   protected:
 127     uint32_t m_count = 0;
 128     uint32_t m_num_buckets = 0;
 129     lldb::addr_t m_buckets_ptr = 0;
 130   };
 131
 132   class NonPointerISACache {
 133   public:
 134     static NonPointerISACache *
 135     CreateInstance(AppleObjCRuntimeV2 &runtime,
 136                    const lldb::ModuleSP &objc_module_sp);
 137
 138     ObjCLanguageRuntime::ClassDescriptorSP GetClassDescriptor(ObjCISA isa);
 139
 140   private:
 141     NonPointerISACache(AppleObjCRuntimeV2 &runtime,
 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
 154     AppleObjCRuntimeV2 &m_runtime;
 155     std::map<ObjCISA, ObjCLanguageRuntime::ClassDescriptorSP> m_cache;
 156     lldb::ModuleWP m_objc_module_wp;
 157     uint64_t m_objc_debug_isa_class_mask;
 158     uint64_t m_objc_debug_isa_magic_mask;
 159     uint64_t m_objc_debug_isa_magic_value;
 160
 161     uint64_t m_objc_debug_indexed_isa_magic_mask;
 162     uint64_t m_objc_debug_indexed_isa_magic_value;
 163     uint64_t m_objc_debug_indexed_isa_index_mask;
 164     uint64_t m_objc_debug_indexed_isa_index_shift;
 165     lldb::addr_t m_objc_indexed_classes;
 166
 167     std::vector<lldb::addr_t> m_indexed_isa_cache;
 168
 169     friend class AppleObjCRuntimeV2;
 170
 171     NonPointerISACache(const NonPointerISACache &) = delete;
 172     const NonPointerISACache &operator=(const NonPointerISACache &) = delete;
 173   };
 174
 175   class TaggedPointerVendorV2
 176       : public ObjCLanguageRuntime::TaggedPointerVendor {
 177   public:
 178     ~TaggedPointerVendorV2() override = default;
 179
 180     static TaggedPointerVendorV2 *
 181     CreateInstance(AppleObjCRuntimeV2 &runtime,
 182                    const lldb::ModuleSP &objc_module_sp);
 183
 184   protected:
 185     AppleObjCRuntimeV2 &m_runtime;
 186
 187     TaggedPointerVendorV2(AppleObjCRuntimeV2 &runtime)
 188         : TaggedPointerVendor(), m_runtime(runtime) {}
 189
 190   private:
 191     TaggedPointerVendorV2(const TaggedPointerVendorV2 &) = delete;
 192     const TaggedPointerVendorV2 &
 193     operator=(const TaggedPointerVendorV2 &) = delete;
 194   };
 195
 196   class TaggedPointerVendorRuntimeAssisted : public TaggedPointerVendorV2 {
 197   public:
 198     bool IsPossibleTaggedPointer(lldb::addr_t ptr) override;
 199
 200     ObjCLanguageRuntime::ClassDescriptorSP
 201     GetClassDescriptor(lldb::addr_t ptr) override;
 202
 203   protected:
 204     TaggedPointerVendorRuntimeAssisted(
 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;
 214     Cache m_cache;
 215     uint64_t m_objc_debug_taggedpointer_mask;
 216     uint32_t m_objc_debug_taggedpointer_slot_shift;
 217     uint32_t m_objc_debug_taggedpointer_slot_mask;
 218     uint32_t m_objc_debug_taggedpointer_payload_lshift;
 219     uint32_t m_objc_debug_taggedpointer_payload_rshift;
 220     lldb::addr_t m_objc_debug_taggedpointer_classes;
 221
 222     friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
 223
 224     TaggedPointerVendorRuntimeAssisted(
 225         const TaggedPointerVendorRuntimeAssisted &) = delete;
 226     const TaggedPointerVendorRuntimeAssisted &
 227     operator=(const TaggedPointerVendorRuntimeAssisted &) = delete;
 228   };
 229
 230   class TaggedPointerVendorExtended
 231       : public TaggedPointerVendorRuntimeAssisted {
 232   public:
 233     ObjCLanguageRuntime::ClassDescriptorSP
 234     GetClassDescriptor(lldb::addr_t ptr) override;
 235
 236   protected:
 237     TaggedPointerVendorExtended(
 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
 251     bool IsPossibleExtendedTaggedPointer(lldb::addr_t ptr);
 252
 253     typedef std::map<uint8_t, ObjCLanguageRuntime::ClassDescriptorSP> Cache;
 254     typedef Cache::iterator CacheIterator;
 255     Cache m_ext_cache;
 256     uint64_t m_objc_debug_taggedpointer_ext_mask;
 257     uint32_t m_objc_debug_taggedpointer_ext_slot_shift;
 258     uint32_t m_objc_debug_taggedpointer_ext_slot_mask;
 259     uint32_t m_objc_debug_taggedpointer_ext_payload_lshift;
 260     uint32_t m_objc_debug_taggedpointer_ext_payload_rshift;
 261     lldb::addr_t m_objc_debug_taggedpointer_ext_classes;
 262
 263     friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
 264
 265     TaggedPointerVendorExtended(const TaggedPointerVendorExtended &) = delete;
 266     const TaggedPointerVendorExtended &
 267     operator=(const TaggedPointerVendorExtended &) = delete;
 268   };
 269
 270   class TaggedPointerVendorLegacy : public TaggedPointerVendorV2 {
 271   public:
 272     bool IsPossibleTaggedPointer(lldb::addr_t ptr) override;
 273
 274     ObjCLanguageRuntime::ClassDescriptorSP
 275     GetClassDescriptor(lldb::addr_t ptr) override;
 276
 277   protected:
 278     TaggedPointerVendorLegacy(AppleObjCRuntimeV2 &runtime)
 279         : TaggedPointerVendorV2(runtime) {}
 280
 281     friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
 282
 283     TaggedPointerVendorLegacy(const TaggedPointerVendorLegacy &) = delete;
 284     const TaggedPointerVendorLegacy &
 285     operator=(const TaggedPointerVendorLegacy &) = delete;
 286   };
 287
 288   struct DescriptorMapUpdateResult {
 289     bool m_update_ran;
 290     bool m_retry_update;
 291     uint32_t m_num_found;
 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
 303     static DescriptorMapUpdateResult Success(uint32_t found) {
 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.
 311   class ClassInfoExtractor {
 312   public:
 313     ClassInfoExtractor(AppleObjCRuntimeV2 &runtime) : m_runtime(runtime) {}
 314     std::mutex &GetMutex() { return m_mutex; }
 315
 316   protected:
 317     /// The lifetime of this object is tied to that of the runtime.
 318     AppleObjCRuntimeV2 &m_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.
 332   class DynamicClassInfoExtractor : public ClassInfoExtractor {
 333   public:
 334     DynamicClassInfoExtractor(AppleObjCRuntimeV2 &runtime)
 335         : ClassInfoExtractor(runtime) {}
 336
 337     DescriptorMapUpdateResult
 338     UpdateISAToDescriptorMap(RemoteNXMapTable &hash_table);
 339
 340   private:
 341     enum Helper {
 342       gdb_objc_realized_classes,
 343       objc_copyRealizedClassList,
 344       objc_getRealizedClassList_trylock
 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
 353     UtilityFunction *GetClassInfoUtilityFunction(ExecutionContext &exe_ctx,
 354                                                  Helper helper);
 355     lldb::addr_t &GetClassInfoArgs(Helper helper);
 356
 357     std::unique_ptr<UtilityFunction>
 358     GetClassInfoUtilityFunctionImpl(ExecutionContext &exe_ctx, Helper helper,
 359                                     std::string code, std::string name);
 360
 361     struct UtilityFunctionHelper {
 362       std::unique_ptr<UtilityFunction> utility_function;
 363       lldb::addr_t args = LLDB_INVALID_ADDRESS;
 364     };
 365
 366     UtilityFunctionHelper m_gdb_objc_realized_classes_helper;
 367     UtilityFunctionHelper m_objc_copyRealizedClassList_helper;
 368     UtilityFunctionHelper m_objc_getRealizedClassList_trylock_helper;
 369   };
 370
 371   /// Abstraction to read the Objective-C class info from the shared cache.
 372   class SharedCacheClassInfoExtractor : public ClassInfoExtractor {
 373   public:
 374     SharedCacheClassInfoExtractor(AppleObjCRuntimeV2 &runtime)
 375         : ClassInfoExtractor(runtime) {}
 376
 377     DescriptorMapUpdateResult UpdateISAToDescriptorMap();
 378
 379   private:
 380     UtilityFunction *GetClassInfoUtilityFunction(ExecutionContext &exe_ctx);
 381
 382     std::unique_ptr<UtilityFunction>
 383     GetClassInfoUtilityFunctionImpl(ExecutionContext &exe_ctx);
 384
 385     std::unique_ptr<UtilityFunction> m_utility_function;
 386     lldb::addr_t m_args = LLDB_INVALID_ADDRESS;
 387   };
 388
 389   class SharedCacheImageHeaders {
 390   public:
 391     static std::unique_ptr<SharedCacheImageHeaders>
 392     CreateSharedCacheImageHeaders(AppleObjCRuntimeV2 &runtime);
 393
 394     void SetNeedsUpdate() { m_needs_update = true; }
 395
 396     bool IsImageLoaded(uint16_t image_index);
 397
 398     uint64_t GetVersion();
 399
 400   private:
 401     SharedCacheImageHeaders(AppleObjCRuntimeV2 &runtime,
 402                             lldb::addr_t headerInfoRWs_ptr, uint32_t count,
 403                             uint32_t entsize)
 404         : m_runtime(runtime), m_headerInfoRWs_ptr(headerInfoRWs_ptr),
 405           m_loaded_images(count, false), m_version(0), m_count(count),
 406           m_entsize(entsize), m_needs_update(true) {}
 407     llvm::Error UpdateIfNeeded();
 408
 409     AppleObjCRuntimeV2 &m_runtime;
 410     lldb::addr_t m_headerInfoRWs_ptr;
 411     llvm::BitVector m_loaded_images;
 412     uint64_t m_version;
 413     uint32_t m_count;
 414     uint32_t m_entsize;
 415     bool m_needs_update;
 416   };
 417
 418   AppleObjCRuntimeV2(Process *process, const lldb::ModuleSP &objc_module_sp);
 419
 420   ObjCISA GetPointerISA(ObjCISA isa);
 421
 422   lldb::addr_t GetISAHashTablePointer();
 423
 424   /// Update the generation count of realized classes. This is not an exact
 425   /// count but rather a value that is incremented when new classes are realized
 426   /// or destroyed. Unlike the count in gdb_objc_realized_classes, it will
 427   /// change when lazily named classes get realized.
 428   bool RealizedClassGenerationCountChanged();
 429
 430   uint32_t ParseClassInfoArray(const lldb_private::DataExtractor &data,
 431                                uint32_t num_class_infos);
 432
 433   enum class SharedCacheWarningReason {
 434     eExpressionUnableToRun,
 435     eExpressionExecutionFailure,
 436     eNotEnoughClassesRead
 437   };
 438
 439   void WarnIfNoClassesCached(SharedCacheWarningReason reason);
 440   void WarnIfNoExpandedSharedCache();
 441
 442   lldb::addr_t GetSharedCacheReadOnlyAddress();
 443   lldb::addr_t GetSharedCacheBaseAddress();
 444
 445   bool GetCFBooleanValuesIfNeeded();
 446
 447   bool HasSymbol(ConstString Name);
 448
 449   NonPointerISACache *GetNonPointerIsaCache() {
 450     if (!m_non_pointer_isa_cache_up)
 451       m_non_pointer_isa_cache_up.reset(
 452           NonPointerISACache::CreateInstance(*this, m_objc_module_sp));
 453     return m_non_pointer_isa_cache_up.get();
 454   }
 455
 456   friend class ClassDescriptorV2;
 457
 458   lldb::ModuleSP m_objc_module_sp;
 459
 460   DynamicClassInfoExtractor m_dynamic_class_info_extractor;
 461   SharedCacheClassInfoExtractor m_shared_cache_class_info_extractor;
 462
 463   std::unique_ptr<DeclVendor> m_decl_vendor_up;
 464   lldb::addr_t m_tagged_pointer_obfuscator;
 465   lldb::addr_t m_isa_hash_table_ptr;
 466   lldb::addr_t m_relative_selector_base;
 467   HashTableSignature m_hash_signature;
 468   bool m_has_object_getClass;
 469   bool m_has_objc_copyRealizedClassList;
 470   bool m_has_objc_getRealizedClassList_trylock;
 471   bool m_loaded_objc_opt;
 472   std::unique_ptr<NonPointerISACache> m_non_pointer_isa_cache_up;
 473   std::unique_ptr<TaggedPointerVendor> m_tagged_pointer_vendor_up;
 474   EncodingToTypeSP m_encoding_to_type_sp;
 475   std::once_flag m_no_classes_cached_warning;
 476   std::once_flag m_no_expanded_cache_warning;
 477   std::optional<std::pair<lldb::addr_t, lldb::addr_t>> m_CFBoolean_values;
 478   uint64_t m_realized_class_generation_count;
 479   std::unique_ptr<SharedCacheImageHeaders> m_shared_cache_image_headers_up;
 480 };
 481
 482 } // namespace lldb_private
 483
 484 #endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCRUNTIMEV2_H