Allow SILGen to emit only a specific set of SILDeclRefs

Extend ASTLoweringDescriptor to store a set of
SILDeclRefs to emit through `emitFunctionDefinition`.

Author: hamishknight

include/swift/AST/SILGenRequests.h

@@ -20,6 +20,7 @@
 #include "swift/AST/ASTTypeIDs.h"
 #include "swift/AST/EvaluatorDependencies.h"
 #include "swift/AST/SimpleRequest.h"
+#include "swift/SIL/SILDeclRef.h"
 
 namespace swift {
 
@@ -40,22 +41,30 @@ template<typename Request>
 void reportEvaluatedRequest(UnifiedStatsReporter &stats,
                             const Request &request);
 
+using SILRefsToEmit = llvm::SmallVector<SILDeclRef, 1>;
+
 /// Describes a file or module to be lowered to SIL.
 struct ASTLoweringDescriptor {
   llvm::PointerUnion<FileUnit *, ModuleDecl *> context;
   Lowering::TypeConverter &conv;
   const SILOptions &opts;
 
+  /// A specific set of SILDeclRefs to emit. If set, only these refs will be
+  /// emitted. Otherwise the entire \c context will be emitted.
+  Optional<SILRefsToEmit> refsToEmit;
+
   friend llvm::hash_code hash_value(const ASTLoweringDescriptor &owner) {
     return llvm::hash_combine(owner.context, (void *)&owner.conv,
-                              (void *)&owner.opts);
+                              (void *)&owner.opts,
+                              owner.refsToEmit);
   }
 
   friend bool operator==(const ASTLoweringDescriptor &lhs,
                          const ASTLoweringDescriptor &rhs) {
     return lhs.context == rhs.context &&
            &lhs.conv == &rhs.conv &&
-           &lhs.opts == &rhs.opts;
+           &lhs.opts == &rhs.opts &&
+           lhs.refsToEmit == rhs.refsToEmit;
   }
 
   friend bool operator!=(const ASTLoweringDescriptor &lhs,
@@ -65,14 +74,16 @@ struct ASTLoweringDescriptor {
 
 public:
   static ASTLoweringDescriptor
-  forFile(FileUnit &sf, Lowering::TypeConverter &conv, const SILOptions &opts) {
-    return ASTLoweringDescriptor{&sf, conv, opts};
+  forFile(FileUnit &sf, Lowering::TypeConverter &conv, const SILOptions &opts,
+          Optional<SILRefsToEmit> refsToEmit = None) {
+    return ASTLoweringDescriptor{&sf, conv, opts, refsToEmit};
   }
 
-  static ASTLoweringDescriptor forWholeModule(ModuleDecl *mod,
-                                              Lowering::TypeConverter &conv,
-                                              const SILOptions &opts) {
-    return ASTLoweringDescriptor{mod, conv, opts};
+  static ASTLoweringDescriptor
+  forWholeModule(ModuleDecl *mod, Lowering::TypeConverter &conv,
+                 const SILOptions &opts,
+                 Optional<SILRefsToEmit> refsToEmit = None) {
+    return ASTLoweringDescriptor{mod, conv, opts, refsToEmit};
   }
 
   /// Retrieves the files to generate SIL for. If the descriptor is configured

include/swift/Basic/AnyValue.h

@@ -29,6 +29,14 @@ namespace llvm {
   hash_code hash_value(const llvm::PointerUnion<PT1, PT2> &ptr) {
     return hash_value(ptr.getOpaqueValue());
   }
+
+  // FIXME: Belongs in LLVM itself
+  template<typename T>
+  hash_code hash_value(const llvm::Optional<T> &opt) {
+    if (!opt)
+      return 1;
+    return hash_value(*opt);
+  }
 }
 
 namespace swift {

include/swift/SIL/SILDeclRef.h

@@ -277,10 +277,10 @@ struct SILDeclRef {
   SILLinkage getLinkage(ForDefinition_t forDefinition) const;
 
   /// Return the hash code for the SIL declaration.
-  llvm::hash_code getHashCode() const {
-    return llvm::hash_combine(loc.getOpaqueValue(),
-                              static_cast<int>(kind),
-                              isForeign, defaultArgIndex);
+  friend llvm::hash_code hash_value(const SILDeclRef &ref) {
+    return llvm::hash_combine(ref.loc.getOpaqueValue(),
+                              static_cast<int>(ref.kind),
+                              ref.isForeign, ref.defaultArgIndex);
   }
 
   bool operator==(SILDeclRef rhs) const {

lib/SILGen/SILGen.cpp

@@ -1910,6 +1910,9 @@ class SILGenModuleRAII {
       SGM.visit(TD);
     }
   }
+  void emitSILFunctionDefinition(SILDeclRef ref) {
+    SGM.emitFunctionDefinition(ref, SGM.getFunction(ref, ForDefinition));
+  }
 
   explicit SILGenModuleRAII(SILModule &M) : SGM{M, M.getSwiftModule()} {}
 
@@ -1942,11 +1945,17 @@ ASTLoweringRequest::evaluate(Evaluator &evaluator,
     return llvm::cantFail(evaluator(ParseSILModuleRequest{desc}));
   }
 
-  // Otherwise perform SIL generation of the passed SourceFiles.
   auto silMod = SILModule::createEmptyModule(desc.context, desc.conv,
                                              desc.opts);
   SILGenModuleRAII scope(*silMod);
 
+  // Emit a specific set of SILDeclRefs if needed.
+  if (auto refs = desc.refsToEmit) {
+    for (auto ref : *refs)
+      scope.emitSILFunctionDefinition(ref);
+  }
+
+  // Emit any whole-files needed.
   for (auto file : desc.getFilesToEmit()) {
     if (auto *nextSF = dyn_cast<SourceFile>(file))
       scope.emitSourceFile(nextSF);

lib/SILGen/SILGenRequests.cpp

@@ -61,6 +61,11 @@ evaluator::DependencySource ASTLoweringRequest::readDependencySource(
 }
 
 ArrayRef<FileUnit *> ASTLoweringDescriptor::getFilesToEmit() const {
+  // If we have a specific set of SILDeclRefs to emit, we don't emit any whole
+  // files.
+  if (refsToEmit)
+    return {};
+
   if (auto *mod = context.dyn_cast<ModuleDecl *>())
     return mod->getFiles();
 

lib/SILOptimizer/Transforms/CSE.cpp

@@ -374,7 +374,7 @@ class HashVisitor : public SILInstructionVisitor<HashVisitor, llvm::hash_code> {
     OperandValueArrayRef Operands(X->getAllOperands());
     return llvm::hash_combine(X->getKind(),
                               X->getLookupType().getPointer(),
-                              X->getMember().getHashCode(),
+                              X->getMember(),
                               X->getConformance(),
                               X->getType(),
                               !X->getTypeDependentOperands().empty(),