[IRGen] Factor out compileAndWriteLLVM

Factor out the logic that deals with the LLVM
passes for compiling and emitting the module.

Author: hamishknight

include/swift/Subsystems.h

@@ -232,6 +232,15 @@ namespace swift {
   void performLLVMOptimizations(const IRGenOptions &Opts, llvm::Module *Module,
                                 llvm::TargetMachine *TargetMachine);
 
+  /// Compiles and writes the given LLVM module into an output stream in the
+  /// format specified in the \c IRGenOptions.
+  bool compileAndWriteLLVM(llvm::Module *module,
+                           llvm::TargetMachine *targetMachine,
+                           const IRGenOptions &opts,
+                           UnifiedStatsReporter *stats, DiagnosticEngine &diags,
+                           llvm::raw_pwrite_stream &out,
+                           llvm::sys::Mutex *diagMutex = nullptr);
+
   /// Wrap a serialized module inside a swift AST section in an object file.
   void createSwiftModuleObjectFile(SILModule &SILMod, StringRef Buffer,
                                    StringRef OutputPath);

lib/IRGen/IRGen.cpp

@@ -536,62 +536,74 @@ bool swift::performLLVM(const IRGenOptions &Opts,
 
   performLLVMOptimizations(Opts, Module, TargetMachine);
 
+  if (Stats) {
+    if (DiagMutex)
+      DiagMutex->lock();
+    countStatsPostIRGen(*Stats, *Module);
+    if (DiagMutex)
+      DiagMutex->unlock();
+  }
+
+  if (!RawOS)
+    return false;
+
+  return compileAndWriteLLVM(Module, TargetMachine, Opts, Stats, Diags, *RawOS,
+                             DiagMutex);
+}
+
+bool swift::compileAndWriteLLVM(llvm::Module *module,
+                                llvm::TargetMachine *targetMachine,
+                                const IRGenOptions &opts,
+                                UnifiedStatsReporter *stats,
+                                DiagnosticEngine &diags,
+                                llvm::raw_pwrite_stream &out,
+                                llvm::sys::Mutex *diagMutex) {
   legacy::PassManager EmitPasses;
 
   // Set up the final emission passes.
-  switch (Opts.OutputKind) {
+  switch (opts.OutputKind) {
   case IRGenOutputKind::Module:
     break;
   case IRGenOutputKind::LLVMAssembly:
-    EmitPasses.add(createPrintModulePass(*RawOS));
+    EmitPasses.add(createPrintModulePass(out));
     break;
   case IRGenOutputKind::LLVMBitcode: {
-    if (Opts.LLVMLTOKind == IRGenLLVMLTOKind::Thin) {
-      EmitPasses.add(createWriteThinLTOBitcodePass(*RawOS));
+    if (opts.LLVMLTOKind == IRGenLLVMLTOKind::Thin) {
+      EmitPasses.add(createWriteThinLTOBitcodePass(out));
     } else {
-      EmitPasses.add(createBitcodeWriterPass(*RawOS));
+      EmitPasses.add(createBitcodeWriterPass(out));
     }
     break;
   }
   case IRGenOutputKind::NativeAssembly:
   case IRGenOutputKind::ObjectFile: {
     CodeGenFileType FileType;
-    FileType = (Opts.OutputKind == IRGenOutputKind::NativeAssembly
-                  ? CGFT_AssemblyFile
-                  : CGFT_ObjectFile);
-
+    FileType =
+        (opts.OutputKind == IRGenOutputKind::NativeAssembly ? CGFT_AssemblyFile
+                                                            : CGFT_ObjectFile);
     EmitPasses.add(createTargetTransformInfoWrapperPass(
-        TargetMachine->getTargetIRAnalysis()));
+        targetMachine->getTargetIRAnalysis()));
 
-    bool fail = TargetMachine->addPassesToEmitFile(EmitPasses, *RawOS, nullptr,
-                                                   FileType, !Opts.Verify);
+    bool fail = targetMachine->addPassesToEmitFile(EmitPasses, out, nullptr,
+                                                   FileType, !opts.Verify);
     if (fail) {
-      diagnoseSync(Diags, DiagMutex,
-                   SourceLoc(), diag::error_codegen_init_fail);
+      diagnoseSync(diags, diagMutex, SourceLoc(),
+                   diag::error_codegen_init_fail);
       return true;
     }
     break;
   }
   }
 
-  if (Stats) {
-    if (DiagMutex)
-      DiagMutex->lock();
-    countStatsPostIRGen(*Stats, *Module);
-    if (DiagMutex)
-      DiagMutex->unlock();
-  }
+  EmitPasses.run(*module);
 
-  EmitPasses.run(*Module);
-
-  if (Stats && RawOS.hasValue()) {
-    if (DiagMutex)
-      DiagMutex->lock();
-    Stats->getFrontendCounters().NumLLVMBytesOutput += RawOS->tell();
-    if (DiagMutex)
-      DiagMutex->unlock();
+  if (stats) {
+    if (diagMutex)
+      diagMutex->lock();
+    stats->getFrontendCounters().NumLLVMBytesOutput += out.tell();
+    if (diagMutex)
+      diagMutex->unlock();
   }
-
   return false;
 }