[lldb] Remove RTTI in ClangExternalASTSourceCommon based on a global map of known instances

[teemperor]

Summary

Currently we do our RTTI check for ClangExternalASTSourceCommon by using this global map of
ClangExternalASTSourceCommon where every instance is registering and deregistering itself
on creation/destruction. Then we can do the RTTI check by looking up in this map from ClangASTContext.

This patch removes this whole thing and just adds LLVM-style RTTI support to ClangExternalASTSourceCommon
which is possible with D71397.

[teemperor]

Ran clang-format on the patch.

[labath]

yay

[teemperor]

• Rebased.

lldb/include/lldb/Symbol/ClangExternalASTSourceCommon.h

union {
     uint64_t m_isa_ptr;
   };
 
   bool m_union_is_user_id : 1, m_union_is_isa_ptr : 1, m_has_object_ptr : 1,
       m_is_self : 1, m_is_dynamic_cxx : 1;
 };
 
 class ClangExternalASTSourceCommon : public clang::ExternalASTSource {
+
+  /// LLVM-style RTTI.
+  static char ID;
+
 public:
-  ClangExternalASTSourceCommon();
   ~ClangExternalASTSourceCommon() override;
 
   ClangASTMetadata *GetMetadata(const clang::Decl *object);
   void SetMetadata(const clang::Decl *object,
                    const ClangASTMetadata &metadata) {
     m_decl_metadata[object] = metadata;
   }
 
   ClangASTMetadata *GetMetadata(const clang::Type *object);
   void SetMetadata(const clang::Type *object,
                    const ClangASTMetadata &metadata) {
     m_type_metadata[object] = metadata;
   }
 
-  static ClangExternalASTSourceCommon *Lookup(clang::ExternalASTSource *source);
-
+  /// LLVM-style RTTI.
+  /// \{
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || ExternalASTSource::isA(ClassID);
+  }
+  static bool classof(const ExternalASTSource *S) { return S->isA(&ID); }
+  /// \}
 private:
   typedef llvm::DenseMap<const clang::Decl *, ClangASTMetadata> DeclMetadataMap;
   typedef llvm::DenseMap<const clang::Type *, ClangASTMetadata> TypeMetadataMap;
 
   DeclMetadataMap m_decl_metadata;
   TypeMetadataMap m_type_metadata;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangExternalASTSourceCommon_h

lldb/source/Symbol/ClangASTContext.cpp

void ClangASTContext::SetMetadataAsUserID(const clang::Type *type,
                                           user_id_t user_id) {
   ClangASTMetadata meta_data;
   meta_data.SetUserID(user_id);
   SetMetadata(type, meta_data);
 }
 
 void ClangASTContext::SetMetadata(const clang::Decl *object,
                                   ClangASTMetadata &metadata) {
-  ClangExternalASTSourceCommon *external_source =
-      ClangExternalASTSourceCommon::Lookup(
-          getASTContext()->getExternalSource());
-
-  if (external_source)
-    external_source->SetMetadata(object, metadata);
+  if (auto *A = llvm::dyn_cast_or_null<ClangExternalASTSourceCommon>(
+          getASTContext()->getExternalSource()))
+    A->SetMetadata(object, metadata);
 }
 
 void ClangASTContext::SetMetadata(const clang::Type *object,
                                   ClangASTMetadata &metadata) {
-  ClangExternalASTSourceCommon *external_source =
-      ClangExternalASTSourceCommon::Lookup(
-          getASTContext()->getExternalSource());
-
-  if (external_source)
-    external_source->SetMetadata(object, metadata);
+  if (auto *A = llvm::dyn_cast_or_null<ClangExternalASTSourceCommon>(
+          getASTContext()->getExternalSource()))
+    A->SetMetadata(object, metadata);
 }
 
 ClangASTMetadata *ClangASTContext::GetMetadata(clang::ASTContext *ast,
                                                const clang::Decl *object) {
-  ClangExternalASTSourceCommon *external_source =
-      ClangExternalASTSourceCommon::Lookup(ast->getExternalSource());
-
-  if (external_source)
-    return external_source->GetMetadata(object);
+  if (auto *A = llvm::dyn_cast_or_null<ClangExternalASTSourceCommon>(
+          ast->getExternalSource()))
+    return A->GetMetadata(object);
   return nullptr;
 }
 
 ClangASTMetadata *ClangASTContext::GetMetadata(clang::ASTContext *ast,
                                                const clang::Type *object) {
-  ClangExternalASTSourceCommon *external_source =
-      ClangExternalASTSourceCommon::Lookup(ast->getExternalSource());
-
-  if (external_source)
-    return external_source->GetMetadata(object);
+  if (auto *A = llvm::dyn_cast_or_null<ClangExternalASTSourceCommon>(
+          ast->getExternalSource()))
+    return A->GetMetadata(object);
   return nullptr;
 }
 
 bool ClangASTContext::SetTagTypeKind(clang::QualType tag_qual_type,
                                      int kind) const {
   const clang::Type *clang_type = tag_qual_type.getTypePtr();
   if (clang_type) {
     const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(clang_type);

lldb/source/Symbol/ClangExternalASTSourceCommon.cpp

 //===-- ClangExternalASTSourceCommon.cpp ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Utility/Stream.h"
 
 #include <mutex>
 
 using namespace lldb_private;
 
-typedef llvm::DenseMap<clang::ExternalASTSource *,
-                       ClangExternalASTSourceCommon *>
-    ASTSourceMap;
-
-static ASTSourceMap &GetSourceMap(std::unique_lock<std::mutex> &guard) {
-  // Intentionally leaked to avoid problems with global destructors.
-  static ASTSourceMap *s_source_map = new ASTSourceMap;
-  static std::mutex s_mutex;
-  std::unique_lock<std::mutex> locked_guard(s_mutex);
-  guard.swap(locked_guard);
-  return *s_source_map;
-}
-
-ClangExternalASTSourceCommon *
-ClangExternalASTSourceCommon::Lookup(clang::ExternalASTSource *source) {
-  std::unique_lock<std::mutex> guard;
-  ASTSourceMap &source_map = GetSourceMap(guard);
-
-  ASTSourceMap::iterator iter = source_map.find(source);
-
-  if (iter != source_map.end()) {
-    return iter->second;
-  } else {
-    return nullptr;
-  }
-}
+char ClangExternalASTSourceCommon::ID;
 
-ClangExternalASTSourceCommon::ClangExternalASTSourceCommon()
-    : clang::ExternalASTSource() {
-  std::unique_lock<std::mutex> guard;
-  GetSourceMap(guard)[this] = this;
-}
-
-ClangExternalASTSourceCommon::~ClangExternalASTSourceCommon() {
-  std::unique_lock<std::mutex> guard;
-  GetSourceMap(guard).erase(this);
-}
+ClangExternalASTSourceCommon::~ClangExternalASTSourceCommon() {}
 
 ClangASTMetadata *
 ClangExternalASTSourceCommon::GetMetadata(const clang::Decl *object) {
   auto It = m_decl_metadata.find(object);
   if (It != m_decl_metadata.end())
     return &It->second;
   return nullptr;
 }