[NFC] Cache objcImpl requests in ClangImporter

This reduces the memory overhead of objcImpl from one word per Decl to one bit per Decl, at the cost of making cache lookups slightly slower (but it will only be consulted once for non-objcImpl decls, which is by far the most common case).

Author: beccadax

include/swift/AST/Decl.h

@@ -355,7 +355,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   // for the inline bitfields.
   union { uint64_t OpaqueBits;
 
-  SWIFT_INLINE_BITFIELD_BASE(Decl, bitmax(NumDeclKindBits,8)+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD_BASE(Decl, bitmax(NumDeclKindBits,8)+1+1+1+1+1+1+1,
     Kind : bitmax(NumDeclKindBits,8),
 
     /// Whether this declaration is invalid.
@@ -381,7 +381,12 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     Hoisted : 1,
 
     /// Whether the set of semantic attributes has been computed.
-    SemanticAttrsComputed : 1
+    SemanticAttrsComputed : 1,
+
+    /// True if \c ObjCInterfaceAndImplementationRequest has been computed
+    /// and did \em not find anything. This is the fast path where we can bail
+    /// out without checking other caches or computing anything.
+    LacksObjCInterfaceOrImplementation : 1
   );
 
   SWIFT_INLINE_BITFIELD_FULL(PatternBindingDecl, Decl, 1+1+2+16,
@@ -816,13 +821,6 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
 private:
   llvm::PointerUnion<DeclContext *, ASTContext *> Context;
 
-  /// The imported Clang declaration representing the \c @_objcInterface for
-  /// this declaration (or vice versa), or \c nullptr if there is none.
-  ///
-  /// If \c this (an otherwise nonsensical value), the value has not yet been
-  /// computed.
-  Decl *CachedObjCImplementationDecl;
-
   Decl(const Decl&) = delete;
   void operator=(const Decl&) = delete;
   SourceLoc getLocFromSource() const;
@@ -840,14 +838,15 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
 protected:
 
   Decl(DeclKind kind, llvm::PointerUnion<DeclContext *, ASTContext *> context)
-    : Context(context), CachedObjCImplementationDecl(this) {
+    : Context(context) {
     Bits.OpaqueBits = 0;
     Bits.Decl.Kind = unsigned(kind);
     Bits.Decl.Invalid = false;
     Bits.Decl.Implicit = false;
     Bits.Decl.FromClang = false;
     Bits.Decl.EscapedFromIfConfig = false;
     Bits.Decl.Hoisted = false;
+    Bits.Decl.LacksObjCInterfaceOrImplementation = false;
   }
 
   /// Get the Clang node associated with this declaration.
@@ -1179,18 +1178,12 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   /// \seeAlso ExtensionDecl::isObjCInterface()
   Decl *getObjCImplementationDecl() const;
 
-  llvm::Optional<Decl *> getCachedObjCImplementationDecl() const {
-    if (CachedObjCImplementationDecl == this)
-      return llvm::None;
-    return CachedObjCImplementationDecl;
+  bool getCachedLacksObjCInterfaceOrImplementation() const {
+    return Bits.Decl.LacksObjCInterfaceOrImplementation;
   }
 
-  void setCachedObjCImplementationDecl(Decl *decl) {
-    assert((CachedObjCImplementationDecl == this
-              || CachedObjCImplementationDecl == decl)
-               && "can't change CachedObjCInterfaceDecl once it's computed");
-    assert(decl != this && "can't form circular reference");
-    CachedObjCImplementationDecl = decl;
+  void setCachedLacksObjCInterfaceOrImplementation(bool value) {
+    Bits.Decl.LacksObjCInterfaceOrImplementation = value;
   }
 
   /// Return the GenericContext if the Decl has one.

include/swift/ClangImporter/ClangImporter.h

@@ -132,6 +132,12 @@ typedef llvm::PointerUnion<const clang::Decl *, const clang::MacroInfo *,
 class ClangImporter final : public ClangModuleLoader {
   friend class ClangModuleUnit;
 
+  // Make requests in the ClangImporter zone friends so they can access `Impl`.
+#define SWIFT_REQUEST(Zone, Name, Sig, Caching, LocOptions)                    \
+  friend class Name;
+#include "swift/ClangImporter/ClangImporterTypeIDZone.def"
+#undef SWIFT_REQUEST
+
 public:
   class Implementation;
 

lib/ClangImporter/ClangImporterRequests.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/SourceFile.h"
 #include "swift/ClangImporter/ClangImporterRequests.h"
 #include "swift/Subsystems.h"
+#include "ImporterImpl.h"
 
 using namespace swift;
 
@@ -27,49 +28,56 @@ ObjCInterfaceAndImplementationRequest::getCachedResult() const {
   if (!passedDecl)
     return {};
 
-  auto cachedDecl = passedDecl->getCachedObjCImplementationDecl();
-
-  // !cachedDecl means that no decl has been cached and we need to evaluate the
-  // request.
-  if (!cachedDecl)
-    return llvm::None;
-
-  // nullptr cachedDecl means that the lack of a decl was cached.
-  else if (!*cachedDecl)
+  if (!passedDecl->getCachedLacksObjCInterfaceOrImplementation())
+    // We've computed this request and found that this is a normal declaration.
     return {};
 
-  // A decl was cached! Arbitrarily guess that we looked up the implementation
-  // from the interface.
-  ObjCInterfaceAndImplementation result{passedDecl, *cachedDecl};
-
-  // An imported decl can only be an interface; a native decl can only be an
-  // implementation. If `implementationDecl` has a Clang node, we must have
-  // looked up the interface from the implementation.
-  if (result.implementationDecl->hasClangNode())
-    std::swap(result.interfaceDecl, result.implementationDecl);
+  // Either we've computed this request and cached a result in the ImporterImpl,
+  // or we haven't computed this request. Check the caches.
+  auto &ctx = passedDecl->getASTContext();
+  auto importer = static_cast<ClangImporter *>(ctx.getClangModuleLoader());
+  auto &impl = importer->Impl;
+
+  if (passedDecl->hasClangNode()) {
+    // `passedDecl` *could* be an interface.
+    auto iter = impl.ImplementationsByInterface.find(passedDecl);
+    if (iter != impl.ImplementationsByInterface.end())
+      return ObjCInterfaceAndImplementation(passedDecl, iter->second);
+  } else {
+    // `passedDecl` *could* be an implementation.
+    auto iter = impl.InterfacesByImplementation.find(passedDecl);
+    if (iter != impl.InterfacesByImplementation.end())
+      return ObjCInterfaceAndImplementation(iter->second, passedDecl);
+  }
 
-  return result;
+  // Nothing in the caches, so we must need to compute this.
+  return llvm::None;
 }
 
 void ObjCInterfaceAndImplementationRequest::
 cacheResult(ObjCInterfaceAndImplementation value) const {
-  Decl *decl = std::get<0>(getStorage());
+  Decl *passedDecl = std::get<0>(getStorage());
 
   if (!value) {
-    // `decl` is neither an interface nor an implementation.
-    decl->setCachedObjCImplementationDecl(nullptr);
+    // `decl` is neither an interface nor an implementation; remember this.
+    passedDecl->setCachedLacksObjCInterfaceOrImplementation(true);
     return;
   }
 
   // Cache computed pointers from implementations to interfaces.
-  value.interfaceDecl->
-      setCachedObjCImplementationDecl(value.implementationDecl);
-  value.implementationDecl->
-      setCachedObjCImplementationDecl(value.interfaceDecl);
+  auto &ctx = passedDecl->getASTContext();
+  auto importer = static_cast<ClangImporter *>(ctx.getClangModuleLoader());
+  auto &impl = importer->Impl;
+
+  impl.ImplementationsByInterface.insert({ value.interfaceDecl,
+                                           value.implementationDecl });
+  impl.InterfacesByImplementation.insert({ value.implementationDecl,
+                                           value.interfaceDecl });
 
   // If this was a duplicate implementation, cache a null so we don't recompute.
-  if (decl != value.interfaceDecl && decl != value.implementationDecl)
-    decl->setCachedObjCImplementationDecl(nullptr);
+  if (!passedDecl->hasClangNode() && passedDecl != value.implementationDecl) {
+    passedDecl->setCachedLacksObjCInterfaceOrImplementation(true);
+  }
 }
 
 // Define request evaluation functions for each of the name lookup requests.

lib/ClangImporter/ImporterImpl.h

@@ -585,6 +585,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   // Mapping from imported types to their raw value types.
   llvm::DenseMap<const NominalTypeDecl *, Type> RawTypes;
 
+  // Caches used by ObjCInterfaceAndImplementationRequest.
+  llvm::DenseMap<Decl *, Decl *> ImplementationsByInterface;
+  llvm::DenseMap<Decl *, Decl *> InterfacesByImplementation;
+
   clang::CompilerInstance *getClangInstance() {
     return Instance.get();
   }