Merge the IRGen requests

Similar to SILGen, merge `IRGenSourceFileRequest`
and `IRGenWholeModuleRequest` into a single
`IRGenRequest`.

Author: hamishknight

include/swift/AST/IRGenRequests.h

@@ -172,6 +172,13 @@ struct IRGenDescriptor {
                            outModuleHash,
                            LinkerDirectives};
   }
+
+  /// Retrieves the files to perform IR generation for.
+  TinyPtrVector<FileUnit *> getFiles() const;
+
+  /// For a single file, returns its parent module, otherwise returns the module
+  /// itself.
+  ModuleDecl *getParentModule() const;
 };
 
 /// Report that a request of the given kind is being evaluated, so it
@@ -180,10 +187,10 @@ template<typename Request>
 void reportEvaluatedRequest(UnifiedStatsReporter &stats,
                             const Request &request);
 
-class IRGenSourceFileRequest
-    : public SimpleRequest<IRGenSourceFileRequest,
-                           GeneratedModule(IRGenDescriptor),
-                           RequestFlags::Uncached|RequestFlags::DependencySource> {
+class IRGenRequest
+    : public SimpleRequest<IRGenRequest, GeneratedModule(IRGenDescriptor),
+                           RequestFlags::Uncached |
+                               RequestFlags::DependencySource> {
 public:
   using SimpleRequest::SimpleRequest;
 
@@ -194,33 +201,12 @@ class IRGenSourceFileRequest
   GeneratedModule
   evaluate(Evaluator &evaluator, IRGenDescriptor desc) const;
 
-public:
-  bool isCached() const { return true; }
-
 public:
   // Incremental dependencies.
   evaluator::DependencySource
   readDependencySource(const evaluator::DependencyRecorder &) const;
 };
 
-class IRGenWholeModuleRequest
-    : public SimpleRequest<IRGenWholeModuleRequest,
-                           GeneratedModule(IRGenDescriptor),
-                           RequestFlags::Uncached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  // Evaluation.
-  GeneratedModule
-  evaluate(Evaluator &evaluator, IRGenDescriptor desc) const;
-
-public:
-  bool isCached() const { return true; }
-};
-
 void simple_display(llvm::raw_ostream &out, const IRGenDescriptor &d);
 
 SourceLoc extractNearestSourceLoc(const IRGenDescriptor &desc);

include/swift/AST/IRGenTypeIDZone.def

@@ -14,10 +14,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-SWIFT_REQUEST(IRGen, IRGenSourceFileRequest,
+SWIFT_REQUEST(IRGen, IRGenRequest,
               GeneratedModule(IRGenDescriptor),
               Uncached, NoLocationInfo)
-SWIFT_REQUEST(IRGen, IRGenWholeModuleRequest,
-              GeneratedModule(IRGenDescriptor),
-              Uncached, NoLocationInfo)
-

lib/IRGen/IRGen.cpp

@@ -889,14 +889,16 @@ static void runIRGenPreparePasses(SILModule &Module,
 
 /// Generates LLVM IR, runs the LLVM passes and produces the output file.
 /// All this is done in a single thread.
-static GeneratedModule
-performIRGeneration(const IRGenOptions &Opts, ModuleDecl *M,
-                    std::unique_ptr<SILModule> SILMod, StringRef ModuleName,
-                    const PrimarySpecificPaths &PSPs,
-                    StringRef PrivateDiscriminator,
-                    SourceFile *SF = nullptr,
-                    llvm::GlobalVariable **outModuleHash = nullptr,
-                    llvm::StringSet<> *linkerDirectives = nullptr) {
+GeneratedModule IRGenRequest::evaluate(Evaluator &evaluator,
+                                       IRGenDescriptor desc) const {
+  const auto &Opts = desc.Opts;
+  const auto &PSPs = desc.PSPs;
+
+  auto SILMod = std::unique_ptr<SILModule>(desc.SILMod);
+  auto *M = desc.getParentModule();
+  auto filesToEmit = desc.getFiles();
+  auto *primaryFile = desc.Ctx.dyn_cast<SourceFile *>();
+
   auto &Ctx = M->getASTContext();
   assert(!Ctx.hadError());
 
@@ -906,9 +908,9 @@ performIRGeneration(const IRGenOptions &Opts, ModuleDecl *M,
   if (!targetMachine) return GeneratedModule::null();
 
   // Create the IR emitter.
-  IRGenModule IGM(irgen, std::move(targetMachine), SF, ModuleName,
+  IRGenModule IGM(irgen, std::move(targetMachine), primaryFile, desc.ModuleName,
                   PSPs.OutputFilename, PSPs.MainInputFilenameForDebugInfo,
-                  PrivateDiscriminator);
+                  desc.PrivateDiscriminator);
 
   initLLVMModule(IGM, *SILMod);
 
@@ -919,24 +921,17 @@ performIRGeneration(const IRGenOptions &Opts, ModuleDecl *M,
     FrontendStatsTracer tracer(Ctx.Stats, "IRGen");
 
     // Emit the module contents.
-    irgen.emitGlobalTopLevel(linkerDirectives);
-
-    if (SF) {
-      IGM.emitSourceFile(*SF);
-      // Emit synthesized file unit, if it exists.
-      if (auto *synthesizedFile = SF->getSynthesizedFile())
-        IGM.emitSynthesizedFileUnit(*synthesizedFile);
-    } else {
-      for (auto *File : M->getFiles()) {
-        if (auto *nextSF = dyn_cast<SourceFile>(File)) {
-          IGM.emitSourceFile(*nextSF);
-        } else if (auto *nextSFU = dyn_cast<SynthesizedFileUnit>(File)) {
-          IGM.emitSynthesizedFileUnit(*nextSFU);
-        } else {
-          File->collectLinkLibraries([&IGM](LinkLibrary LinkLib) {
-            IGM.addLinkLibrary(LinkLib);
-          });
-        }
+    irgen.emitGlobalTopLevel(desc.LinkerDirectives);
+
+    for (auto *file : filesToEmit) {
+      if (auto *nextSF = dyn_cast<SourceFile>(file)) {
+        IGM.emitSourceFile(*nextSF);
+      } else if (auto *nextSFU = dyn_cast<SynthesizedFileUnit>(file)) {
+        IGM.emitSynthesizedFileUnit(*nextSFU);
+      } else {
+        file->collectLinkLibraries([&IGM](LinkLibrary LinkLib) {
+          IGM.addLinkLibrary(LinkLib);
+        });
       }
     }
 
@@ -989,7 +984,7 @@ performIRGeneration(const IRGenOptions &Opts, ModuleDecl *M,
 
   embedBitcode(IGM.getModule(), Opts);
 
-  if (outModuleHash) {
+  if (auto **outModuleHash = desc.outModuleHash) {
     *outModuleHash = IGM.ModuleHash;
   } else {
     FrontendStatsTracer tracer(Ctx.Stats, "LLVM pipeline");
@@ -1306,30 +1301,19 @@ GeneratedModule swift::performIRGeneration(
     const PrimarySpecificPaths &PSPs,
     ArrayRef<std::string> parallelOutputFilenames,
     llvm::GlobalVariable **outModuleHash, llvm::StringSet<> *LinkerDirectives) {
-  auto desc = IRGenDescriptor::forWholeModule(
-      Opts, M, std::move(SILMod), ModuleName, PSPs,
-      parallelOutputFilenames, outModuleHash, LinkerDirectives);
-  return llvm::cantFail(
-      M->getASTContext().evaluator(IRGenWholeModuleRequest{desc}));
-}
-
-GeneratedModule
-IRGenWholeModuleRequest::evaluate(Evaluator &evaluator,
-                                  IRGenDescriptor desc) const {
-  auto *M = desc.Ctx.get<ModuleDecl *>();
-  if (desc.SILMod->getOptions().shouldPerformIRGenerationInParallel() &&
-      !desc.parallelOutputFilenames.empty()) {
-    ::performParallelIRGeneration(
-        desc.Opts, M, std::unique_ptr<SILModule>(desc.SILMod), desc.ModuleName,
-        desc.parallelOutputFilenames, desc.LinkerDirectives);
+  if (SILMod->getOptions().shouldPerformIRGenerationInParallel() &&
+      !parallelOutputFilenames.empty()) {
+    ::performParallelIRGeneration(Opts, M, std::move(SILMod), ModuleName,
+                                  parallelOutputFilenames, LinkerDirectives);
     // TODO: Parallel LLVM compilation cannot be used if a (single) module is
     // needed as return value.
     return GeneratedModule::null();
   }
-  return ::performIRGeneration(
-      desc.Opts, M, std::unique_ptr<SILModule>(desc.SILMod), desc.ModuleName,
-      desc.PSPs, "", nullptr, desc.outModuleHash,
-      desc.LinkerDirectives);
+
+  auto desc = IRGenDescriptor::forWholeModule(
+      Opts, M, std::move(SILMod), ModuleName, PSPs, parallelOutputFilenames,
+      outModuleHash, LinkerDirectives);
+  return llvm::cantFail(M->getASTContext().evaluator(IRGenRequest{desc}));
 }
 
 GeneratedModule swift::
@@ -1342,18 +1326,7 @@ performIRGeneration(const IRGenOptions &Opts, SourceFile &SF,
   auto desc = IRGenDescriptor::forFile(Opts, SF, std::move(SILMod), ModuleName,
                                        PSPs, PrivateDiscriminator,
                                        outModuleHash, LinkerDirectives);
-  return llvm::cantFail(
-      SF.getASTContext().evaluator(IRGenSourceFileRequest{desc}));
-}
-
-GeneratedModule
-IRGenSourceFileRequest::evaluate(Evaluator &evaluator,
-                                 IRGenDescriptor desc) const {
-  auto *SF = desc.Ctx.get<SourceFile *>();
-  return ::performIRGeneration(
-      desc.Opts, SF->getParentModule(), std::unique_ptr<SILModule>(desc.SILMod),
-      desc.ModuleName, desc.PSPs, desc.PrivateDiscriminator,
-      SF, desc.outModuleHash, desc.LinkerDirectives);
+  return llvm::cantFail(SF.getASTContext().evaluator(IRGenRequest{desc}));
 }
 
 void

lib/IRGen/IRGenRequests.cpp

@@ -52,13 +52,40 @@ SourceLoc swift::extractNearestSourceLoc(const IRGenDescriptor &desc) {
   return SourceLoc();
 }
 
-evaluator::DependencySource IRGenSourceFileRequest::readDependencySource(
+TinyPtrVector<FileUnit *> IRGenDescriptor::getFiles() const {
+  // For a whole module, we emit IR for all files.
+  if (auto *mod = Ctx.dyn_cast<ModuleDecl *>())
+    return TinyPtrVector<FileUnit *>(mod->getFiles());
+
+  // For a primary source file, we emit IR for both it and potentially its
+  // SynthesizedFileUnit.
+  auto *SF = Ctx.get<SourceFile *>();
+  TinyPtrVector<FileUnit *> files;
+  files.push_back(SF);
+
+  if (auto *synthesizedFile = SF->getSynthesizedFile())
+    files.push_back(synthesizedFile);
+
+  return files;
+}
+
+ModuleDecl *IRGenDescriptor::getParentModule() const {
+  if (auto *SF = Ctx.dyn_cast<SourceFile *>())
+    return SF->getParentModule();
+  return Ctx.get<ModuleDecl *>();
+}
+
+evaluator::DependencySource IRGenRequest::readDependencySource(
     const evaluator::DependencyRecorder &e) const {
   auto &desc = std::get<0>(getStorage());
-  return {
-    desc.Ctx.dyn_cast<SourceFile *>(),
-    evaluator::DependencyScope::Cascading
-  };
+
+  // We don't track dependencies in whole-module mode.
+  if (auto *mod = desc.Ctx.dyn_cast<ModuleDecl *>()) {
+    return {nullptr, e.getActiveSourceScope()};
+  }
+
+  auto *SF = desc.Ctx.get<SourceFile *>();
+  return {SF, evaluator::DependencyScope::Cascading};
 }
 
 // Define request evaluation functions for each of the IRGen requests.