Only use supplementary outputs for first parallel-generated input.

Author: davidungar

include/swift/Basic/SupplementaryOutputPaths.h

@@ -47,6 +47,14 @@ struct SupplementaryOutputPaths {
 
   SupplementaryOutputPaths() = default;
   SupplementaryOutputPaths(const SupplementaryOutputPaths &) = default;
+
+  bool empty() const {
+    return ObjCHeaderOutputPath.empty() && ModuleOutputPath.empty() &&
+           ModuleDocOutputPath.empty() && DependenciesFilePath.empty() &&
+           ReferenceDependenciesFilePath.empty() &&
+           SerializedDiagnosticsPath.empty() && LoadedModuleTracePath.empty() &&
+           TBDPath.empty();
+  }
 };
 } // namespace swift
 

include/swift/Frontend/FrontendInputsAndOutputs.h

@@ -226,11 +226,11 @@ class FrontendInputsAndOutputs {
   /// to tell it which primary input you wanted the outputs for.
   ///
   /// Must not be constructed on-the-fly because some parts of the compiler
-  /// truck in StringRef's to its components, so it must live as long as the
+  /// receive StringRefs to its components, so it must live as long as the
   /// compiler.
   PrimarySpecificPaths &getPrimarySpecificPathsForAtMostOnePrimary();
 
-  PrimarySpecificPaths &getPrimarySpecificPathsForPrimary(StringRef);
+  PrimarySpecificPaths &getPrimarySpecificPathsForPrimary(StringRef filename);
 
   bool hasDependenciesPath() const;
   bool hasReferenceDependenciesPath() const;

lib/FrontendTool/FrontendTool.cpp

@@ -1065,9 +1065,8 @@ static void setPrivateDiscriminatorIfNeeded(IRGenOptions &IRGenOpts,
     IRGenOpts.DWARFDebugFlags += (" -private-discriminator " + PD.str()).str();
 }
 
-static bool serializeSIB(FrontendOptions &opts, SILModule *SM,
-                         const PrimarySpecificPaths &PSPs, ASTContext &Context,
-                         ModuleOrSourceFile MSF) {
+static bool serializeSIB(SILModule *SM, const PrimarySpecificPaths &PSPs,
+                         ASTContext &Context, ModuleOrSourceFile MSF) {
   const std::string &moduleOutputPath =
       PSPs.SupplementaryOutputs.ModuleOutputPath;
   assert(!moduleOutputPath.empty() && "must have an output path");
@@ -1209,8 +1208,7 @@ static bool performCompileStepsPostSILGen(CompilerInstance &Instance,
 
   if (Action == FrontendOptions::ActionType::EmitSIBGen) {
     linkAllIfNeeded(Invocation, SM.get());
-    serializeSIB(Invocation.getFrontendOptions(), SM.get(), PSPs,
-                 Instance.getASTContext(), MSF);
+    serializeSIB(SM.get(), PSPs, Instance.getASTContext(), MSF);
     return Context.hadError();
   }
 
@@ -1271,8 +1269,7 @@ static bool performCompileStepsPostSILGen(CompilerInstance &Instance,
                             opts.ImplicitObjCHeaderPath, moduleIsPublic);
 
   if (Action == FrontendOptions::ActionType::EmitSIB)
-    return serializeSIB(Invocation.getFrontendOptions(), SM.get(), PSPs,
-                        Instance.getASTContext(), MSF);
+    return serializeSIB(SM.get(), PSPs, Instance.getASTContext(), MSF);
 
   const bool haveModulePath =
       !PSPs.SupplementaryOutputs.ModuleOutputPath.empty() ||

lib/IRGen/IRGen.cpp

@@ -865,12 +865,11 @@ static void ThreadEntryPoint(IRGenerator *irgen,
 
 /// Generates LLVM IR, runs the LLVM passes and produces the output files.
 /// All this is done in multiple threads.
-static void performParallelIRGeneration(IRGenOptions &Opts,
-                                        swift::ModuleDecl *M,
-                                        std::unique_ptr<SILModule> SILMod,
-                                        const PrimarySpecificPaths &PSPs,
-                                        StringRef ModuleName, int numThreads,
-                                        ArrayRef<std::string> outputFilenames) {
+static void performParallelIRGeneration(
+    IRGenOptions &Opts, swift::ModuleDecl *M, std::unique_ptr<SILModule> SILMod,
+    const SupplementaryOutputPaths &supplementaryOutputPathsForFirstInput,
+    StringRef ModuleName, int numThreads,
+    ArrayRef<std::string> outputFilenames) {
 
   IRGenerator irgen(Opts, *SILMod);
 
@@ -903,7 +902,6 @@ static void performParallelIRGeneration(IRGenOptions &Opts,
     // There must be an output filename for each source file.
     // We ignore additional output filenames.
     if (OutputIter == outputFilenames.end()) {
-      // TODO: Check this already at argument parsing.
       Ctx.Diags.diagnose(SourceLoc(), diag::too_few_output_filenames);
       return;
     }
@@ -916,12 +914,12 @@ static void performParallelIRGeneration(IRGenOptions &Opts,
     auto Context = new LLVMContext();
 
     // Create the IR emitter.
-    IRGenModule *IGM = new IRGenModule(irgen, std::move(targetMachine),
-                                       nextSF, *Context,
-                                       ModuleName,
-                                       PrimarySpecificPaths(*OutputIter++,
-                                                          nextSF->getFilename(),
-                                       PSPs.SupplementaryOutputs));
+    const bool isFirst = OutputIter == outputFilenames.begin();
+    IRGenModule *IGM = new IRGenModule(
+        irgen, std::move(targetMachine), nextSF, *Context, ModuleName,
+        PrimarySpecificPaths(*OutputIter++, nextSF->getFilename(),
+                             isFirst ? supplementaryOutputPathsForFirstInput
+                                     : SupplementaryOutputPaths()));
     IGMcreated = true;
 
     initLLVMModule(*IGM);
@@ -1081,17 +1079,17 @@ static void performParallelIRGeneration(IRGenOptions &Opts,
   }
 }
 
-std::unique_ptr<llvm::Module> swift::
-performIRGeneration(IRGenOptions &Opts, swift::ModuleDecl *M,
-                    std::unique_ptr<SILModule> SILMod,
-                    StringRef ModuleName, const PrimarySpecificPaths &PSPs,
-                    llvm::LLVMContext &LLVMContext,
-                    ArrayRef<std::string> parallelOutputFilenames,
-                    llvm::GlobalVariable **outModuleHash) {
+std::unique_ptr<llvm::Module> swift::performIRGeneration(
+    IRGenOptions &Opts, swift::ModuleDecl *M, std::unique_ptr<SILModule> SILMod,
+    StringRef ModuleName, const PrimarySpecificPaths &PSPs,
+    llvm::LLVMContext &LLVMContext,
+    ArrayRef<std::string> parallelOutputFilenames,
+    llvm::GlobalVariable **outModuleHash) {
   if (SILMod->getOptions().shouldPerformIRGenerationInParallel() &&
       !parallelOutputFilenames.empty()) {
     auto NumThreads = SILMod->getOptions().NumThreads;
-    ::performParallelIRGeneration(Opts, M, std::move(SILMod), PSPs, ModuleName,
+    ::performParallelIRGeneration(Opts, M, std::move(SILMod),
+                                  PSPs.SupplementaryOutputs, ModuleName,
                                   NumThreads, parallelOutputFilenames);
     // TODO: Parallel LLVM compilation cannot be used if a (single) module is
     // needed as return value.

lib/SIL/SILModule.cpp

@@ -15,7 +15,6 @@
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/Substitution.h"
-#include "swift/Basic/PrimarySpecificPaths.h"
 #include "swift/SIL/FormalLinkage.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILModule.h"