[llvm-reduce] Add support for LTO bitcode files

[ormris]

Summary

Adds support for reading and writing LTO bitcode files. While this feature can be replicated by stripping and regenerating summaries via opt, this patch makes reducing LTO bitcode a transparent process with no extra boiler-plate. This is especially useful when split LTO units are needed, as the process to generate them can be less than obvious.

[ormris]

Add context

[arsenm]

tools/llvm-reduce/ReducerWorkItem.cpp

425 ↗

(On Diff #434646)

Single quotes around newline

434 ↗

(On Diff #434646)

Why is this returning a default constructed ReducerWorkItem instead of null? I see some other places are doing this but I don't see how this makes sense

441 ↗

(On Diff #434646)

Why does an IR reduction need to initialize target info?

455 ↗

(On Diff #434646)

Why this change?

tools/llvm-reduce/llvm-reduce.cpp

121 ↗

(On Diff #434646)

Do you really need a pass manager (a legacy one at that) just to write out the file? Why isn't there a simple function to use?

137 ↗

(On Diff #434646)

Other places propagate the tool name from argv

144 ↗

(On Diff #434646)

Ditto

[ormris]

tools/llvm-reduce/ReducerWorkItem.cpp

425 ↗

(On Diff #434646)

Fixed.

434 ↗

(On Diff #434646)

I opted for this to stay consistent with the surrounding code. Nonetheless, nullptr is more efficient at the same task, so I'll go ahead and use that instead.

441 ↗

(On Diff #434646)

The ThinLTOBitcodeWriter pass depends on target info. It crashes without it.

455 ↗

(On Diff #434646)

That change is no longer needed. I'll remove it.

tools/llvm-reduce/llvm-reduce.cpp

121 ↗

(On Diff #434646)

Unfortunately, there isn't. If you look at opt, you'll see the same strategy.

137 ↗

(On Diff #434646)

Fixed. I've added the tool name to the TestRunner class, so that it's accessible.

144 ↗

(On Diff #434646)

See above.

[ormris]

• Add toolname to errors
• Remove unnecessary changes

[ormris]

ping

[ormris]

ping ping

[arsenm]

While I don't understand the LTO bitcode files, the reduce changes seem fine

llvm/tools/llvm-reduce/deltas/Delta.cpp

64–66

Don't need llvm:: and these look like they need line wrapping

[ormris]

Sounds good. Thanks for the review.

llvm/test/tools/llvm-reduce/Inputs/llvm-dis-and-filecheck.py

 """
 Script to disassembles a bitcode file and run FileCheck on the output with the
 provided arguments. The first 2 arguments are the paths to the llvm-dis and
 FileCheck binaries, followed by arguments to be passed to FileCheck. The last
 argument is the bitcode file to disassemble.
 
 Usage:
     python llvm-dis-and-filecheck.py
       <path to llvm-dis> <path to FileCheck>
       [arguments passed to FileCheck] <path to bitcode file>
 
 """
 
 
 import sys
+import os
 import subprocess
 
 llvm_dis = sys.argv[1]
 filecheck = sys.argv[2]
 filecheck_args = [filecheck, ]
 filecheck_args.extend(sys.argv[3:-1])
 bitcode_file = sys.argv[-1]
+ir_file = bitcode_file + ".ll"
 
-disassemble = subprocess.Popen([llvm_dis, "-o", "-", bitcode_file],
-        stdout=subprocess.PIPE)
-check = subprocess.Popen(filecheck_args, stdin=disassemble.stdout)
-disassemble.stdout.close()
+disassemble = subprocess.Popen([llvm_dis, "-o", ir_file, bitcode_file])
+if os.path.exists(ir_file + ".0"):
+    ir_file = ir_file + ".0"
+
+disassemble.communicate()
+
+if disassemble.returncode != 0:
+    print("stderr:")
+    print(disassemble.stderr)
+    print("stdout:")
+    print(disassemble.stdout)
+    sys.exit(1)
+
+check=None
+with open(ir_file, "r") as ir:
+    check = subprocess.Popen(filecheck_args, stdin=ir, stdout=sys.stdout)
 check.communicate()
 sys.exit(check.returncode)

llvm/test/tools/llvm-reduce/fail-file-open.test

 # RUN: not llvm-reduce --test=echo %s.NotAFileInTestingDir 2>&1 | FileCheck %s
 
 This file will not be read. An invalid file path is fed to llvm-reduce.
 
-# CHECK: llvm-reduce{{.*}}: {{.*}}.NotAFileInTestingDir: error:
+# CHECK: llvm-reduce{{.*}}: error: {{.*}}.NotAFileInTestingDir:
 

llvm/test/tools/llvm-reduce/invalid-bitcode-error.ll

+; RUN: not %python %p/Inputs/llvm-dis-and-filecheck.py llvm-dis FileCheck %s %s 2>&1 | FileCheck %s
+; CHECK: stderr
+; CHECK: stdout

llvm/test/tools/llvm-reduce/temporary-files-as-bitcode-split.ll

+; RUN: opt --thinlto-bc --thinlto-split-lto-unit %s -o %t0
+; RUN: llvm-reduce -write-tmp-files-as-bitcode --delta-passes=basic-blocks %t0 -o %t1 \
+; RUN:     --test %python --test-arg %p/Inputs/llvm-dis-and-filecheck.py --test-arg llvm-dis --test-arg FileCheck --test-arg --check-prefixes=CHECK-ALL,CHECK-INTERESTINGNESS --test-arg %s
+; RUN: cat %t1* | FileCheck --check-prefixes=CHECK-ALL,CHECK-FINAL %s
+
+@g = internal global i8 42, !type !0
+
+; CHECK-INTERESTINGNESS: @callee(
+; CHECK-FINAL: declare void @callee()
+define void @callee() {
+  ret void
+}
+
+; CHECK-ALL: define void @caller()
+define void @caller() {
+entry:
+; CHECK-ALL: call void @callee()
+; CHECK-ALL: ret void
+  call void @callee()
+  ret void
+}
+define i8* @f() {
+  ; CHECK-ALL: ret i8* @g.{{([0-9a-f]{32})}}
+  ret i8* @g
+}
+
+!0 = !{i32 0, !"typeid"}

llvm/tools/llvm-reduce/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsInfos
   Analysis
   BitReader
   BitWriter
   CodeGen
   Core
   IRReader
   MC
   MIRParser
   Support
   Target
   TransformUtils
+  IPO
   )
 
 add_llvm_tool(llvm-reduce
   DeltaManager.cpp
   ReducerWorkItem.cpp
   TestRunner.cpp
   deltas/Delta.cpp
   deltas/Utils.cpp

llvm/tools/llvm-reduce/ReducerWorkItem.h

 //===- ReducerWorkItem.h - Wrapper for Module and MachineFunction ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_REDUCE_REDUCERWORKITEM_H
 #define LLVM_TOOLS_LLVM_REDUCE_REDUCERWORKITEM_H
 
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/Target/TargetMachine.h"
 
 using namespace llvm;
 
 class ReducerWorkItem {
 public:
   std::shared_ptr<Module> M;
+  std::unique_ptr<BitcodeLTOInfo> LTOInfo;
   std::unique_ptr<MachineModuleInfo> MMI;
 
   bool isMIR() const { return MMI != nullptr; }
 
   const Module &getModule() const { return *M; }
 
   void print(raw_ostream &ROS, void *p = nullptr) const;
   operator Module &() const { return *M; }

llvm/tools/llvm-reduce/ReducerWorkItem.cpp

 //===- ReducerWorkItem.cpp - Wrapper for Module and MachineFunction -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReducerWorkItem.h"
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/CodeGen/MIRParser/MIRParser.h"
 #include "llvm/CodeGen/MIRPrinter.h"
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Host.h"
+#include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 
 extern cl::OptionCategory LLVMReduceOptions;
 static cl::opt<std::string> TargetTriple("mtriple",
                                          cl::desc("Set the target triple"),
                                          cl::cat(LLVMReduceOptions));
 
+void readBitcode(ReducerWorkItem &M, MemoryBufferRef Data, LLVMContext &Ctx, const char *ToolName);
+
 static void cloneFrameInfo(
     MachineFrameInfo &DstMFI, const MachineFrameInfo &SrcMFI,
     const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB) {
   DstMFI.setFrameAddressIsTaken(SrcMFI.isFrameAddressTaken());
   DstMFI.setReturnAddressIsTaken(SrcMFI.isReturnAddressTaken());
   DstMFI.setHasStackMap(SrcMFI.hasStackMap());
   DstMFI.setHasPatchPoint(SrcMFI.hasPatchPoint());
   DstMFI.setUseLocalStackAllocationBlock(
if (!DstMF->cloneInfoFrom(*SrcMF, Src2DstMBB))
     report_fatal_error("target does not implement MachineFunctionInfo cloning");
 
   DstMRI->freezeReservedRegs(*DstMF);
 
   DstMF->verify(nullptr, "", /*AbortOnError=*/true);
   return DstMF;
 }
 
+static void initializeTargetInfo() {
+  InitializeAllTargets();
+  InitializeAllTargetMCs();
+  InitializeAllAsmPrinters();
+  InitializeAllAsmParsers();
+}
+
 std::unique_ptr<ReducerWorkItem>
 parseReducerWorkItem(const char *ToolName, StringRef Filename,
                      LLVMContext &Ctxt, std::unique_ptr<TargetMachine> &TM,
                      bool IsMIR) {
   Triple TheTriple;
 
   auto MMM = std::make_unique<ReducerWorkItem>();
 
   if (IsMIR) {
+    initializeTargetInfo();
+
     auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
     if (std::error_code EC = FileOrErr.getError()) {
       WithColor::error(errs(), ToolName) << EC.message() << '\n';
       return nullptr;
     }
 
     std::unique_ptr<MIRParser> MParser =
         createMIRParser(std::move(FileOrErr.get()), Ctxt);
if (IsMIR) {
     std::unique_ptr<Module> M = MParser->parseIRModule(SetDataLayout);
     LLVMTargetMachine *LLVMTM = static_cast<LLVMTargetMachine *>(TM.get());
 
     MMM->MMI = std::make_unique<MachineModuleInfo>(LLVMTM);
     MParser->parseMachineFunctions(*M, *MMM->MMI);
     MMM->M = std::move(M);
   } else {
     SMDiagnostic Err;
+    ErrorOr<std::unique_ptr<MemoryBuffer>> MB = MemoryBuffer::getFileOrSTDIN(Filename);
+    if (std::error_code EC = MB.getError()) {
+      WithColor::error(errs(), ToolName) << Filename << ": " << EC.message() << "\n";
+      return nullptr;
+    }
+
+    if (!isBitcode((const unsigned char *)(*MB)->getBufferStart(),
+                  (const unsigned char *)(*MB)->getBufferEnd())) {
       std::unique_ptr<Module> Result = parseIRFile(Filename, Err, Ctxt);
       if (!Result) {
         Err.print(ToolName, errs());
-      return std::unique_ptr<ReducerWorkItem>();
+        return nullptr;
       }
       MMM->M = std::move(Result);
+    } else {
+      readBitcode(*MMM, MemoryBufferRef(**MB), Ctxt, ToolName);
+
+      if (MMM->LTOInfo->IsThinLTO && MMM->LTOInfo->EnableSplitLTOUnit)
+       initializeTargetInfo();
+    }
   }
   if (verifyReducerWorkItem(*MMM, &errs())) {
     WithColor::error(errs(), ToolName)
         << Filename << " - input module is broken!\n";
-    return std::unique_ptr<ReducerWorkItem>();
+    return nullptr;
   }
   return MMM;
 }
 
 std::unique_ptr<ReducerWorkItem>
 cloneReducerWorkItem(const ReducerWorkItem &MMM, const TargetMachine *TM) {
   auto CloneMMM = std::make_unique<ReducerWorkItem>();
   if (TM) {

llvm/tools/llvm-reduce/TestRunner.h

 
 // This class contains all the info necessary for running the provided
 // interesting-ness test, as well as the most reduced module and its
 // respective filename.
 class TestRunner {
 public:
   TestRunner(StringRef TestName, const std::vector<std::string> &TestArgs,
              std::unique_ptr<ReducerWorkItem> Program,
-             std::unique_ptr<TargetMachine> TM);
+             std::unique_ptr<TargetMachine> TM, const char *ToolName);
 
   /// Runs the interesting-ness test for the specified file
   /// @returns 0 if test was successful, 1 if otherwise
   int run(StringRef Filename);
 
   /// Returns the most reduced version of the original testcase
   ReducerWorkItem &getProgram() const { return *Program; }
 
   void setProgram(std::unique_ptr<ReducerWorkItem> P);
 
   const TargetMachine *getTargetMachine() const { return TM.get(); }
 
+  const char *getToolName() const { return ToolName; }
+
 private:
   StringRef TestName;
+  const char *ToolName;
   const std::vector<std::string> &TestArgs;
   std::unique_ptr<ReducerWorkItem> Program;
   std::unique_ptr<TargetMachine> TM;
 };
 
 } // namespace llvm
 
 #endif

llvm/tools/llvm-reduce/TestRunner.cpp

 #include "ReducerWorkItem.h"
 #include "llvm/CodeGen/MachineFunction.h"
 
 using namespace llvm;
 
 TestRunner::TestRunner(StringRef TestName,
                        const std::vector<std::string> &TestArgs,
                        std::unique_ptr<ReducerWorkItem> Program,
-                       std::unique_ptr<TargetMachine> TM)
+                       std::unique_ptr<TargetMachine> TM, const char *ToolName)
     : TestName(TestName), TestArgs(TestArgs), Program(std::move(Program)),
-      TM(std::move(TM)) {
+      TM(std::move(TM)), ToolName(ToolName) {
   assert(this->Program && "Initialized with null program?");
 }
 
 /// Runs the interestingness test, passes file to be tested as first argument
 /// and other specified test arguments after that.
 int TestRunner::run(StringRef Filename) {
   std::vector<StringRef> ProgramArgs;
   ProgramArgs.push_back(TestName);

llvm/tools/llvm-reduce/deltas/Delta.cpp

 // it splits a given set of Targets (i.e. Functions, Instructions, BBs, etc.)
 // into chunks and tries to reduce the number chunks that are interesting.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Delta.h"
 #include "ReducerWorkItem.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include <fstream>
 #include <set>
 
 using namespace llvm;
 
 extern cl::OptionCategory LLVMReduceOptions;
cl::desc("Maximum number of threads to use to process chunks. Set to 1 to "
              "disables parallelism."),
     cl::init(1), cl::cat(LLVMReduceOptions));
 #else
 unsigned NumJobs = 1;
 #endif
 
 void writeOutput(ReducerWorkItem &M, llvm::StringRef Message);
 
+void writeBitcode(ReducerWorkItem &M, raw_ostream &OutStream);
+
+void readBitcode(ReducerWorkItem &M, MemoryBufferRef Data, LLVMContext &Ctx,
+                 const char *ToolName);
+
 bool isReduced(ReducerWorkItem &M, TestRunner &Test,
                SmallString<128> &CurrentFilepath) {
   // Write ReducerWorkItem to tmp file
   int FD;
   std::error_code EC = sys::fs::createTemporaryFile(
       "llvm-reduce", M.isMIR() ? "mir" : (TmpFilesAsBitcode ? "bc" : "ll"), FD,
       CurrentFilepath);
   if (EC) {
     errs() << "Error making unique filename: " << EC.message() << "!\n";
     exit(1);
   }
 
   if (TmpFilesAsBitcode) {
     llvm::raw_fd_ostream OutStream(FD, true);
-    WriteBitcodeToFile(M, OutStream);
+    writeBitcode(M, OutStream);
     OutStream.close();
     if (OutStream.has_error()) {
       errs() << "Error emitting bitcode to file '" << CurrentFilepath << "'!\n";
       sys::fs::remove(CurrentFilepath);
       exit(1);
     }
     bool Res = Test.run(CurrentFilepath);
     sys::fs::remove(CurrentFilepath);

 
 template <typename FuncType>
 SmallString<0> ProcessChunkFromSerializedBitcode(
     Chunk &ChunkToCheckForUninterestingness, TestRunner &Test,
     FuncType ExtractChunksFromModule, std::set<Chunk> &UninterestingChunks,
     std::vector<Chunk> &ChunksStillConsideredInteresting,
     SmallString<0> &OriginalBC, std::atomic<bool> &AnyReduced) {
   LLVMContext Ctx;
-  Expected<std::unique_ptr<Module>> MOrErr = parseBitcodeFile(
-      MemoryBufferRef(StringRef(OriginalBC.data(), OriginalBC.size()),
-                      "<llvm-reduce tmp module>"),
-      Ctx);
-  if (!MOrErr)
-    report_fatal_error("Failed to read bitcode");
   auto CloneMMM = std::make_unique<ReducerWorkItem>();
-  CloneMMM->M = std::move(MOrErr.get());
+  auto Data = MemoryBufferRef(StringRef(OriginalBC.data(), OriginalBC.size()),
+                              "<bc file>");
+  readBitcode(*CloneMMM, Data, Ctx, Test.getToolName());
 
   SmallString<0> Result;
   if (std::unique_ptr<ReducerWorkItem> ChunkResult =
           CheckChunk(ChunkToCheckForUninterestingness, std::move(CloneMMM),
                      Test, ExtractChunksFromModule, UninterestingChunks,
                      ChunksStillConsideredInteresting)) {
     raw_svector_ostream BCOS(Result);
-    WriteBitcodeToFile(*ChunkResult->M, BCOS);
+    writeBitcode(*ChunkResult, BCOS);
     // Communicate that the task reduced a chunk.
     AnyReduced = true;
   }
   return Result;
 }
 
 /// Runs the Delta Debugging algorithm, splits the code into chunks and
 /// reduces the amount of chunks that are considered interesting by the
do {
 
     std::set<Chunk> UninterestingChunks;
 
     // When running with more than one thread, serialize the original bitcode
     // to OriginalBC.
     SmallString<0> OriginalBC;
     if (NumJobs > 1) {
       raw_svector_ostream BCOS(OriginalBC);
-      WriteBitcodeToFile(*Test.getProgram().M, BCOS);
+      writeBitcode(Test.getProgram(), BCOS);
     }
 
     std::deque<std::shared_future<SmallString<0>>> TaskQueue;
     for (auto I = ChunksStillConsideredInteresting.rbegin(),
               E = ChunksStillConsideredInteresting.rend();
          I != E; ++I) {
       std::unique_ptr<ReducerWorkItem> Result = nullptr;
       unsigned WorkLeft = std::distance(I, E);
for (auto I = ChunksStillConsideredInteresting.rbegin(),
                         ChunkToCheck, Test, ExtractChunksFromModule,
                         UninterestingChunks, ChunksStillConsideredInteresting,
                         OriginalBC, AnyReduced);
                   }));
             }
             continue;
           }
 
-          Expected<std::unique_ptr<Module>> MOrErr = parseBitcodeFile(
-              MemoryBufferRef(StringRef(Res.data(), Res.size()),
-                              "<llvm-reduce tmp module>"),
-              Test.getProgram().M->getContext());
-          if (!MOrErr)
-            report_fatal_error("Failed to read bitcode");
           Result = std::make_unique<ReducerWorkItem>();
-          Result->M = std::move(MOrErr.get());
+          auto Data = MemoryBufferRef(StringRef(Res.data(), Res.size()),
+                                      "<bc file>");
+          readBitcode(*Result, Data, Test.getProgram().M->getContext(),
+                      Test.getToolName());
           break;
         }
         // Forward I to the last chunk processed in parallel.
         I += NumChunksProcessed - 1;
       } else {
         Result = CheckChunk(
             *I,
             cloneReducerWorkItem(Test.getProgram(), Test.getTargetMachine()),

llvm/tools/llvm-reduce/llvm-reduce.cpp

 // proposal, and thus a *temporary* tool that will eventually be integrated
 // into the bugpoint tool itself.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DeltaManager.h"
 #include "ReducerWorkItem.h"
 #include "TestRunner.h"
+#include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Bitcode/BitcodeReader.h"
+#include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/IPO.h"
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 
 cl::OptionCategory LLVMReduceOptions("llvm-reduce options");
 
 static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden,

 static cl::opt<int>
     MaxPassIterations("max-pass-iterations",
                       cl::desc("Maximum number of times to run the full set "
                                "of delta passes (default=5)"),
                       cl::init(5), cl::cat(LLVMReduceOptions));
 
 static codegen::RegisterCodeGenFlags CGF;
 
-static void initializeTargetInfo() {
-  InitializeAllTargets();
-  InitializeAllTargetMCs();
-  InitializeAllAsmPrinters();
-  InitializeAllAsmParsers();
-}
-
 void writeOutput(ReducerWorkItem &M, StringRef Message) {
   if (ReplaceInput) // In-place
     OutputFilename = InputFilename.c_str();
   else if (OutputFilename.empty() || OutputFilename == "-")
     OutputFilename = M.isMIR() ? "reduced.mir" : "reduced.ll";
   std::error_code EC;
   raw_fd_ostream Out(OutputFilename, EC);
   if (EC) {
     errs() << "Error opening output file: " << EC.message() << "!\n";
     exit(1);
   }
   M.print(Out, /*AnnotationWriter=*/nullptr);
   errs() << Message << OutputFilename << "\n";
 }
 
+void writeBitcode(ReducerWorkItem &M, llvm::raw_ostream &OutStream) {
+  if (M.LTOInfo && M.LTOInfo->IsThinLTO && M.LTOInfo->EnableSplitLTOUnit) {
+    legacy::PassManager PM;
+    PM.add(llvm::createWriteThinLTOBitcodePass(OutStream));
+    PM.run(*(M.M));
+  } else {
+    std::unique_ptr<ModuleSummaryIndex> Index;
+    if (M.LTOInfo && M.LTOInfo->HasSummary) {
+      ProfileSummaryInfo PSI(M);
+      Index = std::make_unique<ModuleSummaryIndex>(
+          buildModuleSummaryIndex(M, nullptr, &PSI));
+    }
+    WriteBitcodeToFile(M, OutStream, Index.get());
+  }
+}
+
+void readBitcode(ReducerWorkItem &M, MemoryBufferRef Data, LLVMContext &Ctx, const char *ToolName) {
+  Expected<BitcodeFileContents> IF = llvm::getBitcodeFileContents(Data);
+  if (!IF) {
+    WithColor::error(errs(), ToolName) << IF.takeError();
+    exit(1);
+  }
+  BitcodeModule BM = IF->Mods[0];
+  Expected<BitcodeLTOInfo> LI = BM.getLTOInfo();
+  Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(Ctx);
+  if (!LI || !MOrErr) {
+    WithColor::error(errs(), ToolName) << IF.takeError();
+    exit(1);
+  }
+  M.LTOInfo = std::make_unique<BitcodeLTOInfo>(*LI);
+  M.M = std::move(MOrErr.get());
+}
+
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
 
   cl::HideUnrelatedOptions({&LLVMReduceOptions, &getColorCategory()});
   cl::ParseCommandLineOptions(Argc, Argv, "LLVM automatic testcase reducer.\n");
 
   bool ReduceModeMIR = false;
   if (InputLanguage != InputLanguages::None) {
     if (InputLanguage == InputLanguages::MIR)
       ReduceModeMIR = true;
   } else if (StringRef(InputFilename).endswith(".mir")) {
     ReduceModeMIR = true;
   }
 
   if (PrintDeltaPasses) {
     printDeltaPasses(errs());
     return 0;
   }
 
-  if (ReduceModeMIR)
-    initializeTargetInfo();
-
   LLVMContext Context;
   std::unique_ptr<TargetMachine> TM;
 
   std::unique_ptr<ReducerWorkItem> OriginalProgram =
       parseReducerWorkItem(Argv[0], InputFilename, Context, TM, ReduceModeMIR);
   if (!OriginalProgram) {
     return 1;
   }
 
   // Initialize test environment
   TestRunner Tester(TestFilename, TestArguments, std::move(OriginalProgram),
-                    std::move(TM));
+                    std::move(TM), Argv[0]);
 
   // Try to reduce code
   runDeltaPasses(Tester, MaxPassIterations);
 
   // Print reduced file to STDOUT
   if (OutputFilename == "-")
     Tester.getProgram().print(outs(), nullptr);
   else
     writeOutput(Tester.getProgram(), "\nDone reducing! Reduced testcase: ");
 
   return 0;
 }