[PM] Wire up support for writing bitcode with new PM.

This moves the old pass creation functionality to its own header and
updates the callers of that routine. Then it adds a new PM supporting
bitcode writer to the header file, and wires that up in the opt tool.
A test is added that round-trips code into bitcode and back out using
the new pass manager.

llvm-svn: 199078

include/llvm/Bitcode/BitcodeWriterPass.h

@@ -0,0 +1,51 @@
+//===-- BitcodeWriterPass.h - Bitcode writing pass --------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file provides a bitcode writing pass.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BITCODE_BITCODE_WRITER_PASS_H
+#define LLVM_BITCODE_BITCODE_WRITER_PASS_H
+
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+class Module;
+class ModulePass;
+class raw_ostream;
+class PreservedAnalyses;
+
+/// \brief Create and return a pass that writes the module to the specified
+/// ostream. Note that this pass is designed for use with the legacy pass
+/// manager.
+ModulePass *createBitcodeWriterPass(raw_ostream &Str);
+
+/// \brief Pass for writing a module of IR out to a bitcode file.
+///
+/// Note that this is intended for use with the new pass manager. To construct
+/// a pass for the legacy pass manager, use the function above.
+class BitcodeWriterPass {
+  raw_ostream &OS;
+
+public:
+  /// \brief Construct a bitcode writer pass around a particular output stream.
+  explicit BitcodeWriterPass(raw_ostream &OS) : OS(OS) {}
+
+  /// \brief Run the bitcode writer pass, and output the module to the selected
+  /// \brief output stream.
+  PreservedAnalyses run(Module *M);
+
+  static StringRef name() { return "BitcodeWriterPass"; }
+};
+
+}
+
+#endif

include/llvm/Bitcode/ReaderWriter.h

@@ -63,10 +63,6 @@ namespace llvm {
   /// should be in "binary" mode.
   void WriteBitcodeToFile(const Module *M, raw_ostream &Out);
 
-  /// createBitcodeWriterPass - Create and return a pass that writes the module
-  /// to the specified ostream.
-  ModulePass *createBitcodeWriterPass(raw_ostream &Str);
-
 
   /// isBitcodeWrapper - Return true if the given bytes are the magic bytes
   /// for an LLVM IR bitcode wrapper.

lib/Bitcode/Writer/BitcodeWriterPass.cpp

@@ -1,4 +1,4 @@
-//===--- Bitcode/Writer/BitcodeWriterPass.cpp - Bitcode Writer ------------===//
+//===- BitcodeWriterPass.cpp - Bitcode writing pass -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -11,10 +11,18 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 using namespace llvm;
 
+PreservedAnalyses BitcodeWriterPass::run(Module *M) {
+  WriteBitcodeToFile(M, OS);
+  return PreservedAnalyses::all();
+}
+
 namespace {
   class WriteBitcodePass : public ModulePass {
     raw_ostream &OS; // raw_ostream to print on
@@ -34,8 +42,6 @@ namespace {
 
 char WriteBitcodePass::ID = 0;
 
-/// createBitcodeWriterPass - Create and return a pass that writes the module
-/// to the specified ostream.
 ModulePass *llvm::createBitcodeWriterPass(raw_ostream &Str) {
   return new WriteBitcodePass(Str);
 }

test/Other/new-pass-manager.ll

@@ -29,6 +29,11 @@
 ; CHECK-NOOP:   ret void
 ; CHECK-NOOP: }
 
+; Round trip through bitcode.
+; RUN: opt -f -o - -passes='no-op-module,no-op-module' %s \
+; RUN:     | llvm-dis \
+; RUN:     | FileCheck %s --check-prefix=CHECK-NOOP
+
 define void @foo() {
   ret void
 }

tools/llvm-extract/llvm-extract.cpp

@@ -14,7 +14,7 @@
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"

tools/opt/NewPMDriver.cpp

@@ -16,6 +16,7 @@
 #include "NewPMDriver.h"
 #include "Passes.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
@@ -44,7 +45,8 @@ bool llvm::runPassPipeline(StringRef Arg0, LLVMContext &Context, Module &M,
     MPM.addPass(PrintModulePass(Out->os()));
     break;
   case OK_OutputBitcode:
-    llvm::report_fatal_error("Bitcode output is not yet implemented!");
+    MPM.addPass(BitcodeWriterPass(Out->os()));
+    break;
   }
 
   // Before executing passes, print the final values of the LLVM options.

tools/opt/opt.cpp

@@ -20,7 +20,7 @@
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/RegionPass.h"
 #include "llvm/Analysis/Verifier.h"
-#include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/DebugInfo.h"
 #include "llvm/IR/DataLayout.h"