Merge pull request #32654 from hamishknight/all-for-ir-and-ir-for-all

Author: hamishknight

include/swift/AST/IRGenOptions.h

@@ -284,6 +284,9 @@ class IRGenOptions {
   /// Whether to disable using mangled names for accessing concrete type metadata.
   unsigned DisableConcreteTypeMetadataMangledNameAccessors : 1;
 
+  /// The number of threads for multi-threaded code generation.
+  unsigned NumThreads = 0;
+
   /// Path to the profdata file to be used for PGO, or the empty string.
   std::string UseProfile = "";
 
@@ -383,6 +386,10 @@ class IRGenOptions {
   llvm::hash_code getPCHHashComponents() const {
     return llvm::hash_value(0);
   }
+
+  bool hasMultipleIRGenThreads() const { return NumThreads > 1; }
+  bool shouldPerformIRGenerationInParallel() const { return NumThreads != 0; }
+  bool hasMultipleIGMs() const { return hasMultipleIRGenThreads(); }
 };
 
 } // end namespace swift

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)
-

include/swift/AST/SILOptions.h

@@ -40,9 +40,6 @@ class SILOptions {
   /// Controls the aggressiveness of the loop unroller.
   int UnrollThreshold = 250;
 
-  /// The number of threads for multi-threaded code generation.
-  unsigned NumThreads = 0;
-  
   /// Controls whether to pull in SIL from partial modules during the
   /// merge modules step. Could perhaps be merged with the link mode
   /// above but the interactions between all the flags are tricky.
@@ -183,10 +180,6 @@ class SILOptions {
   bool shouldOptimize() const {
     return OptMode > OptimizationMode::NoOptimization;
   }
-
-  bool hasMultipleIRGenThreads() const { return NumThreads > 1; }
-  bool shouldPerformIRGenerationInParallel() const { return NumThreads != 0; }
-  bool hasMultipleIGMs() const { return hasMultipleIRGenThreads(); }
 };
 
 } // end namespace swift

lib/Frontend/CompilerInvocation.cpp

@@ -1043,18 +1043,6 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
       return true;
     }
   }
-  if (const Arg *A = Args.getLastArg(OPT_num_threads)) {
-    if (StringRef(A->getValue()).getAsInteger(10, Opts.NumThreads)) {
-      Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
-                     A->getAsString(Args), A->getValue());
-      return true;
-    }
-    if (environmentVariableRequestedMaximumDeterminism()) {
-      Opts.NumThreads = 1;
-      Diags.diagnose(SourceLoc(), diag::remark_max_determinism_overriding,
-                     "-num-threads");
-    }
-  }
 
   // If we're only emitting a module, stop optimizations once we've serialized
   // the SIL for the module.
@@ -1259,7 +1247,7 @@ static bool ParseTBDGenArgs(TBDGenOptions &Opts, ArgList &Args,
                             CompilerInvocation &Invocation) {
   using namespace options;
 
-  Opts.HasMultipleIGMs = Invocation.getSILOptions().hasMultipleIGMs();
+  Opts.HasMultipleIGMs = Invocation.getIRGenOptions().hasMultipleIGMs();
 
   if (const Arg *A = Args.getLastArg(OPT_module_link_name)) {
     Opts.ModuleLinkName = A->getValue();
@@ -1593,6 +1581,19 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
         getRuntimeCompatVersion();
   }
 
+  if (const Arg *A = Args.getLastArg(OPT_num_threads)) {
+    if (StringRef(A->getValue()).getAsInteger(10, Opts.NumThreads)) {
+      Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
+                     A->getAsString(Args), A->getValue());
+      return true;
+    }
+    if (environmentVariableRequestedMaximumDeterminism()) {
+      Opts.NumThreads = 1;
+      Diags.diagnose(SourceLoc(), diag::remark_max_determinism_overriding,
+                     "-num-threads");
+    }
+  }
+
   return false;
 }
 

lib/IRGen/GenDecl.cpp

@@ -443,6 +443,7 @@ class PrettySynthesizedFileUnitEmission : public llvm::PrettyStackTraceEntry {
 
 /// Emit all the top-level code in the source file.
 void IRGenModule::emitSourceFile(SourceFile &SF) {
+  assert(SF.ASTStage == SourceFile::TypeChecked);
   PrettySourceFileEmission StackEntry(SF);
 
   // Emit types and other global decls.

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,25 +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)) {
-          if (nextSF->ASTStage >= SourceFile::TypeChecked)
-            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);
+        });
       }
     }
 
@@ -990,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");
@@ -1138,7 +1132,7 @@ static void performParallelIRGeneration(
   bool DidRunSILCodeGenPreparePasses = false;
   for (auto *File : M->getFiles()) {
     auto nextSF = dyn_cast<SourceFile>(File);
-    if (!nextSF || nextSF->ASTStage < SourceFile::TypeChecked)
+    if (!nextSF)
       continue;
 
     // There must be an output filename for each source file.
@@ -1286,7 +1280,7 @@ static void performParallelIRGeneration(
 
   // Start all the threads and do the LLVM compilation.
 
-  LLVMCodeGenThreads codeGenThreads(&irgen, &DiagMutex, SILMod->getOptions().NumThreads - 1);
+  LLVMCodeGenThreads codeGenThreads(&irgen, &DiagMutex, Opts.NumThreads - 1);
   codeGenThreads.startThreads();
 
   // Free the memory occupied by the SILModule.
@@ -1307,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 (Opts.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::
@@ -1343,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.