uselistorder: Pull bit through BitcodeWriterPass

Now the callers of `BitcodeWriterPass` decide whether or not to preserve
bitcode use-list order.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@234959 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Bitcode/BitcodeWriterPass.h

@@ -26,7 +26,11 @@ 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);
+///
+/// If \c ShouldPreserveUseListOrder, encode use-list order so it can be
+/// reproduced when deserialized.
+ModulePass *createBitcodeWriterPass(raw_ostream &Str,
+                                    bool ShouldPreserveUseListOrder = false);
 
 /// \brief Pass for writing a module of IR out to a bitcode file.
 ///
@@ -34,10 +38,16 @@ ModulePass *createBitcodeWriterPass(raw_ostream &Str);
 /// a pass for the legacy pass manager, use the function above.
 class BitcodeWriterPass {
   raw_ostream &OS;
+  bool ShouldPreserveUseListOrder;
 
 public:
   /// \brief Construct a bitcode writer pass around a particular output stream.
-  explicit BitcodeWriterPass(raw_ostream &OS) : OS(OS) {}
+  ///
+  /// If \c ShouldPreserveUseListOrder, encode use-list order so it can be
+  /// reproduced when deserialized.
+  explicit BitcodeWriterPass(raw_ostream &OS,
+                             bool ShouldPreserveUseListOrder = false)
+      : OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
 
   /// \brief Run the bitcode writer pass, and output the module to the selected
   /// output stream.

lib/Bitcode/Writer/BitcodeWriterPass.cpp

@@ -20,22 +20,25 @@
 using namespace llvm;
 
 PreservedAnalyses BitcodeWriterPass::run(Module &M) {
-  WriteBitcodeToFile(&M, OS, shouldPreserveBitcodeUseListOrder());
+  WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder);
   return PreservedAnalyses::all();
 }
 
 namespace {
   class WriteBitcodePass : public ModulePass {
     raw_ostream &OS; // raw_ostream to print on
+    bool ShouldPreserveUseListOrder;
+
   public:
     static char ID; // Pass identification, replacement for typeid
-    explicit WriteBitcodePass(raw_ostream &o)
-      : ModulePass(ID), OS(o) {}
+    explicit WriteBitcodePass(raw_ostream &o, bool ShouldPreserveUseListOrder)
+        : ModulePass(ID), OS(o),
+          ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
 
     const char *getPassName() const override { return "Bitcode Writer"; }
 
     bool runOnModule(Module &M) override {
-      WriteBitcodeToFile(&M, OS, shouldPreserveBitcodeUseListOrder());
+      WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder);
       return false;
     }
   };
@@ -43,6 +46,7 @@ namespace {
 
 char WriteBitcodePass::ID = 0;
 
-ModulePass *llvm::createBitcodeWriterPass(raw_ostream &Str) {
-  return new WriteBitcodePass(Str);
+ModulePass *llvm::createBitcodeWriterPass(raw_ostream &Str,
+                                          bool ShouldPreserveUseListOrder) {
+  return new WriteBitcodePass(Str, ShouldPreserveUseListOrder);
 }

tools/llvm-extract/llvm-extract.cpp

@@ -272,7 +272,8 @@ int main(int argc, char **argv) {
   if (OutputAssembly)
     Passes.add(createPrintModulePass(Out.os()));
   else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true))
-    Passes.add(createBitcodeWriterPass(Out.os()));
+    Passes.add(
+        createBitcodeWriterPass(Out.os(), shouldPreserveBitcodeUseListOrder()));
 
   Passes.run(*M.get());
 

tools/opt/NewPMDriver.cpp

@@ -39,7 +39,8 @@ static cl::opt<bool>
 bool llvm::runPassPipeline(StringRef Arg0, LLVMContext &Context, Module &M,
                            TargetMachine *TM, tool_output_file *Out,
                            StringRef PassPipeline, OutputKind OK,
-                           VerifierKind VK) {
+                           VerifierKind VK,
+                           bool ShouldPreserveBitcodeUseListOrder) {
   PassBuilder PB(TM);
 
   FunctionAnalysisManager FAM(DebugPM);
@@ -80,7 +81,8 @@ bool llvm::runPassPipeline(StringRef Arg0, LLVMContext &Context, Module &M,
     MPM.addPass(PrintModulePass(Out->os()));
     break;
   case OK_OutputBitcode:
-    MPM.addPass(BitcodeWriterPass(Out->os()));
+    MPM.addPass(
+        BitcodeWriterPass(Out->os(), ShouldPreserveBitcodeUseListOrder));
     break;
   }
 

tools/opt/NewPMDriver.h

@@ -51,7 +51,8 @@ enum VerifierKind {
 bool runPassPipeline(StringRef Arg0, LLVMContext &Context, Module &M,
                      TargetMachine *TM, tool_output_file *Out,
                      StringRef PassPipeline, opt_tool::OutputKind OK,
-                     opt_tool::VerifierKind VK);
+                     opt_tool::VerifierKind VK,
+                     bool ShouldPreserveBitcodeUseListOrder);
 }
 
 #endif

tools/opt/opt.cpp

@@ -431,7 +431,8 @@ int main(int argc, char **argv) {
     // string. Hand off the rest of the functionality to the new code for that
     // layer.
     return runPassPipeline(argv[0], Context, *M, TM.get(), Out.get(),
-                           PassPipeline, OK, VK)
+                           PassPipeline, OK, VK,
+                           shouldPreserveBitcodeUseListOrder())
                ? 0
                : 1;
   }
@@ -594,7 +595,8 @@ int main(int argc, char **argv) {
     if (OutputAssembly)
       Passes.add(createPrintModulePass(Out->os()));
     else
-      Passes.add(createBitcodeWriterPass(Out->os()));
+      Passes.add(createBitcodeWriterPass(Out->os(),
+                                         shouldPreserveBitcodeUseListOrder()));
   }
 
   // Before executing passes, print the final values of the LLVM options.