From e005d71e4b5447df00e4b8e17d14b1fbcbf29196 Mon Sep 17 00:00:00 2001 From: "Duncan P. N. Exon Smith" Date: Wed, 15 Apr 2015 00:34:24 +0000 Subject: [PATCH] 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 | 14 ++++++++++++-- lib/Bitcode/Writer/BitcodeWriterPass.cpp | 16 ++++++++++------ tools/llvm-extract/llvm-extract.cpp | 3 ++- tools/opt/NewPMDriver.cpp | 6 ++++-- tools/opt/NewPMDriver.h | 3 ++- tools/opt/opt.cpp | 6 ++++-- 6 files changed, 34 insertions(+), 14 deletions(-) diff --git a/include/llvm/Bitcode/BitcodeWriterPass.h b/include/llvm/Bitcode/BitcodeWriterPass.h index 8fe9b7e8434..ae915c688ba 100644 --- a/include/llvm/Bitcode/BitcodeWriterPass.h +++ b/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. diff --git a/lib/Bitcode/Writer/BitcodeWriterPass.cpp b/lib/Bitcode/Writer/BitcodeWriterPass.cpp index fccc9e7a231..ddb121a109a 100644 --- a/lib/Bitcode/Writer/BitcodeWriterPass.cpp +++ b/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); } diff --git a/tools/llvm-extract/llvm-extract.cpp b/tools/llvm-extract/llvm-extract.cpp index 443ee653c8e..d67b41bea21 100644 --- a/tools/llvm-extract/llvm-extract.cpp +++ b/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()); diff --git a/tools/opt/NewPMDriver.cpp b/tools/opt/NewPMDriver.cpp index 9216d5c939a..8d4b279c6f7 100644 --- a/tools/opt/NewPMDriver.cpp +++ b/tools/opt/NewPMDriver.cpp @@ -39,7 +39,8 @@ static cl::opt 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; } diff --git a/tools/opt/NewPMDriver.h b/tools/opt/NewPMDriver.h index 5384fe295e1..e9a751da250 100644 --- a/tools/opt/NewPMDriver.h +++ b/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 diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp index b0951a4887e..8946558d219 100644 --- a/tools/opt/opt.cpp +++ b/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. -- 2.34.1