llvm-reduce: Support emitting bitcode for final result

[arsenm]

Summary

Previously, this unconditionally emitted text IR. I ran
into a bug that manifested in broken disassembly, so the
desired output was the bitcode format. If the input format
was binary bitcode, the requested output file ends in .bc,
or an explicit -output-bitcode option was used, emit bitcode.

[arsenm]

My specialty continues to be failing on the most common case

[aeubanks]

wdyt about replacing -output-bitcode with -output-type=autodetect|bitcode|text, defaulting to autodetect? that seems conceptually cleaner than this logic, which has a weird imbalance between preferring bitcode vs text

[arsenm]

In D136791#3893379, @aeubanks wrote:

wdyt about replacing -output-bitcode with -output-type=autodetect|bitcode|text, defaulting to autodetect? that seems conceptually cleaner than this logic, which has a weird imbalance between preferring bitcode vs text

I thought about doing this. We have so little consistency throughout the tools for this. Most seem to use -S to switch to text, and I don't think any try to detect based on the file extension. Since it's a reduction tool, the most sensible thing would probably be to just consistently reuse the input type (this also applies to -write-tmp-files-as-bitcode. Most of the tools happen to accept .ll or .bc inputs, but you could be reducing something that specifically needs one or the other)

[arsenm]

Drop file extension based guess. Just preserve the input format, or follow the existing flag

[aeubanks]

llvm/test/tools/llvm-reduce/Inputs/test-output-format.ll

2

can you use llvm-as instead of checking in the .bc file?

llvm/tools/llvm-reduce/ReducerWorkItem.h

47

returning std::pair<std::unique_ptr<ReducerWorkItem>, bool> and using C++17 structured bindings seems nicer

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

161

does auto [OutputFileName, OutputBitcode] = work?

[arsenm]

3c436ab0d457a83e8efaf74745a7672a09d6f3a3 and 4e21bc0c40a79957e6a979c6c9d364906341cdd4

llvm/test/tools/llvm-reduce/Inputs/test-output-format.ll

+
+define void @foo(ptr %ptr) {
+  store i32 0, ptr %ptr
+  store i32 1, ptr %ptr
+  ret void
+}

llvm/test/tools/llvm-reduce/Inputs/test-output-format.mir

+---
+name: func
+tracksRegLiveness: true
+body:             |
+  bb.0:
+
+    %ptr:_(p0) = G_IMPLICIT_DEF
+    %const0:_(s32) = G_CONSTANT i32 0
+    G_STORE %const0, %ptr :: (store 4, addrspace 1)
+    %const1:_(s32) = G_CONSTANT i32 1
+    G_STORE %const1, %ptr :: (store 4, addrspace 1)
+...

llvm/test/tools/llvm-reduce/file-output-type.test

+# RUN: rm -f reduced.ll reduced.bc
+
+# A .ll input file should default to text output in reduced.ll
+# RUN: llvm-reduce --delta-passes=instructions --test FileCheck --test-arg %s --test-arg --input-file %p/Inputs/test-output-format.ll
+# RUN: llvm-as -disable-output reduced.ll
+
+
+# A .bc input file should default to bitcode output, in reduced.bc
+# RUN: rm -f reduced.ll reduced.bc
+# RUN: llvm-reduce --delta-passes=instructions --test FileCheck --test-arg %s --test-arg --input-file %p/Inputs/test-output-format.bc
+# RUN: llvm-dis -disable-output reduced.bc
+
+
+# A .bc input file with a requested .bc output should produce bitcode
+# RUN: llvm-reduce --delta-passes=instructions -o %t.0.bc --test FileCheck --test-arg %s --test-arg --input-file %p/Inputs/test-output-format.bc
+# RUN: llvm-dis -disable-output %t.0.bc
+
+
+# A .bc input file with a requested .ll output
+# RUN: rm -f reduced.ll reduced.bc
+# RUN: llvm-reduce --delta-passes=instructions -o %t.0.ll --test FileCheck --test-arg %s --test-arg --input-file %p/Inputs/test-output-format.bc
+# RUN: llvm-dis -disable-output %t.0.ll
+
+
+# A file name ending in .bc
+# RUN: llvm-reduce -o %t.1.bc --delta-passes=instructions --test FileCheck --test-arg %s --test-arg --input-file %p/Inputs/test-output-format.ll
+# RUN: llvm-as -disable-output %t.1.bc
+
+
+# Make sure an explicit -output-bitcode produces bitcode output regardless of suffix
+# RUN: llvm-reduce -output-bitcode -o %t.2_no_suffix --delta-passes=instructions --test FileCheck --test-arg %s --test-arg --input-file %p/Inputs/test-output-format.ll
+# RUN: llvm-dis -disable-output %t.2_no_suffix
+
+
+# Make sure an explicit -output-bitcode overrides .ll suffix
+# RUN: llvm-reduce -output-bitcode -o %t.2.ll --delta-passes=instructions --test FileCheck --test-arg %s --test-arg --input-file %p/Inputs/test-output-format.ll
+# RUN: llvm-dis -disable-output %t.2.ll
+
+
+# Make sure MIR ignores requests for bitcode
+# RUN: llvm-reduce -output-bitcode --delta-passes=instructions -o %t.3  --test FileCheck --test-arg --check-prefix=MIR --test-arg %s --test-arg --input-file %p/Inputs/test-output-format.mir
+# RUN: llc -x mir -run-pass=none -o /dev/null %t.3
+
+
+# CHECK: store i32 0
+# MIR: G_CONSTANT i32 0

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=function-bodies,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
+; RUN: llvm-dis < %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
 }

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

 ; RUN: llvm-reduce -write-tmp-files-as-bitcode --delta-passes=function-bodies,basic-blocks %s -o %t \
 ; 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 %t | FileCheck --check-prefixes=CHECK-ALL,CHECK-FINAL %s
+; RUN: FileCheck --check-prefixes=CHECK-ALL,CHECK-FINAL %s < %t
 
 ; 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
 }

llvm/tools/llvm-reduce/ReducerWorkItem.h

 private:
   uint64_t computeIRComplexityScore() const;
   uint64_t computeMIRComplexityScore() const;
 };
 
 std::unique_ptr<ReducerWorkItem>
 parseReducerWorkItem(const char *ToolName, StringRef Filename,
                      LLVMContext &Ctxt, std::unique_ptr<TargetMachine> &TM,
-                     bool IsMIR);
+                     bool IsMIR, bool &IsBitcode);
 
 std::unique_ptr<ReducerWorkItem>
 cloneReducerWorkItem(const ReducerWorkItem &MMM, const TargetMachine *TM);
 
 bool verifyReducerWorkItem(const ReducerWorkItem &MMM, raw_fd_ostream *OS);
 
 #endif

llvm/tools/llvm-reduce/ReducerWorkItem.cpp

static void initializeTargetInfo() {
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 }
 
 std::unique_ptr<ReducerWorkItem>
 parseReducerWorkItem(const char *ToolName, StringRef Filename,
                      LLVMContext &Ctxt, std::unique_ptr<TargetMachine> &TM,
-                     bool IsMIR) {
+                     bool IsMIR, bool &IsBitcode) {
   Triple TheTriple;
 
   auto MMM = std::make_unique<ReducerWorkItem>();
 
   if (IsMIR) {
     initializeTargetInfo();
 
     auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
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 nullptr;
       }
       MMM->M = std::move(Result);
     } else {
+      IsBitcode = true;
       readBitcode(*MMM, MemoryBufferRef(**MB), Ctxt, ToolName);
 
       if (MMM->LTOInfo->IsThinLTO && MMM->LTOInfo->EnableSplitLTOUnit)
        initializeTargetInfo();
     }
   }
   if (verifyReducerWorkItem(*MMM, &errs())) {
     WithColor::error(errs(), ToolName)

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, const char *ToolName);
+             std::unique_ptr<TargetMachine> TM, const char *ToolName,
+             StringRef OutputFilename, bool OutputBitcode);
 
   /// 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; }
 
+  void writeOutput(StringRef Message);
+
 private:
   StringRef TestName;
   const char *ToolName;
   const std::vector<std::string> &TestArgs;
   std::unique_ptr<ReducerWorkItem> Program;
   std::unique_ptr<TargetMachine> TM;
+  StringRef OutputFilename;
+  bool EmitBitcode;
 };
 
 } // namespace llvm
 
 #endif

llvm/tools/llvm-reduce/TestRunner.cpp

 //===-- TestRunner.cpp ----------------------------------------------------===//
 //
 // 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 "TestRunner.h"
 #include "ReducerWorkItem.h"
 #include "deltas/Utils.h"
+#include "llvm/Analysis/ModuleSummaryAnalysis.h"
+#include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/Bitcode/BitcodeReader.h"
+#include "llvm/Bitcode/BitcodeWriter.h"
+#include "llvm/Passes/PassBuilder.h"
+#include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
 
 using namespace llvm;
 
 TestRunner::TestRunner(StringRef TestName,
                        const std::vector<std::string> &TestArgs,
                        std::unique_ptr<ReducerWorkItem> Program,
-                       std::unique_ptr<TargetMachine> TM, const char *ToolName)
+                       std::unique_ptr<TargetMachine> TM, const char *ToolName,
+                       StringRef OutputName, bool OutputBitcode)
     : TestName(TestName), ToolName(ToolName), TestArgs(TestArgs),
-      Program(std::move(Program)), TM(std::move(TM)) {
+      Program(std::move(Program)), TM(std::move(TM)),
+      OutputFilename(OutputName), EmitBitcode(OutputBitcode) {
   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);
int TestRunner::run(StringRef Filename) {
 
   return !Result;
 }
 
 void TestRunner::setProgram(std::unique_ptr<ReducerWorkItem> P) {
   assert(P && "Setting null program?");
   Program = std::move(P);
 }
+
+void writeBitcode(ReducerWorkItem &M, raw_ostream &OutStream) {
+  if (M.LTOInfo && M.LTOInfo->IsThinLTO && M.LTOInfo->EnableSplitLTOUnit) {
+    PassBuilder PB;
+    LoopAnalysisManager LAM;
+    FunctionAnalysisManager FAM;
+    CGSCCAnalysisManager CGAM;
+    ModuleAnalysisManager MAM;
+    PB.registerModuleAnalyses(MAM);
+    PB.registerCGSCCAnalyses(CGAM);
+    PB.registerFunctionAnalyses(FAM);
+    PB.registerLoopAnalyses(LAM);
+    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+    ModulePassManager MPM;
+    MPM.addPass(ThinLTOBitcodeWriterPass(OutStream, nullptr));
+    MPM.run(*M.M, MAM);
+  } 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 TestRunner::writeOutput(StringRef Message) {
+  std::error_code EC;
+  raw_fd_ostream Out(OutputFilename, EC);
+  if (EC) {
+    errs() << "Error opening output file: " << EC.message() << "!\n";
+    exit(1);
+  }
+
+  // Requesting bitcode emission with mir is nonsense, so just ignore it.
+  if (EmitBitcode && !Program->isMIR())
+    writeBitcode(*Program, Out);
+  else
+    Program->print(Out, /*AnnotationWriter=*/nullptr);
+
+  errs() << Message << OutputFilename << '\n';
+}

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

static cl::opt<unsigned> NumJobs(
     "j",
     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
for (auto I = ChunksStillConsideredInteresting.rbegin(),
         continue;
 
       Chunk &ChunkToCheckForUninterestingness = *I;
       FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = true;
       UninterestingChunks.insert(ChunkToCheckForUninterestingness);
       ReducedProgram = std::move(Result);
 
       // FIXME: Report meaningful progress info
-      writeOutput(*ReducedProgram, " **** SUCCESS | Saved new best reduction to ");
+      Test.writeOutput(" **** SUCCESS | Saved new best reduction to ");
     }
     // Delete uninteresting chunks
     erase_if(ChunksStillConsideredInteresting,
              [&UninterestingChunks](const Chunk &C) {
                return UninterestingChunks.count(C);
              });
   } while (!ChunksStillConsideredInteresting.empty() &&
            (FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity ||

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/ModuleSummaryAnalysis.h"
-#include "llvm/Analysis/ProfileSummaryInfo.h"
-#include "llvm/Bitcode/BitcodeReader.h"
-#include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/CommandFlags.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/IRReader/IRReader.h"
-#include "llvm/Passes/PassBuilder.h"
+
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.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,
TestFilename("test", cl::Required,
                  cl::cat(LLVMReduceOptions));
 
 static cl::list<std::string>
     TestArguments("test-arg",
                   cl::desc("Arguments passed onto the interesting-ness test"),
                   cl::cat(LLVMReduceOptions));
 
 static cl::opt<std::string> OutputFilename(
-    "output", cl::desc("Specify the output file. default: reduced.ll|mir"));
+    "output",
+    cl::desc("Specify the output file. default: reduced.ll|.bc|.mir"));
 static cl::alias OutputFileAlias("o", cl::desc("Alias for -output"),
                                  cl::aliasopt(OutputFilename),
                                  cl::cat(LLVMReduceOptions));
 
 static cl::opt<bool>
     ReplaceInput("in-place",
                  cl::desc("WARNING: This option will replace your input file "
                           "with the reduced version!"),
                  cl::cat(LLVMReduceOptions));
 
 enum class InputLanguages { None, IR, MIR };
 
 static cl::opt<InputLanguages>
     InputLanguage("x", cl::ValueOptional,
                   cl::desc("Input language ('ir' or 'mir')"),
                   cl::init(InputLanguages::None),
                   cl::values(clEnumValN(InputLanguages::IR, "ir", ""),
                              clEnumValN(InputLanguages::MIR, "mir", "")),
                   cl::cat(LLVMReduceOptions));
 
+static cl::opt<bool> ForceOutputBitcode(
+    "output-bitcode",
+    cl::desc("Emit final result as bitcode instead of text IR"), cl::Hidden,
+    cl::cat(LLVMReduceOptions));
+
 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;
 
 bool isReduced(ReducerWorkItem &M, TestRunner &Test);
 
-void writeOutput(ReducerWorkItem &M, StringRef Message) {
-  if (ReplaceInput) // In-place
+static std::pair<StringRef, bool> determineOutputType(bool IsMIR,
+                                                      bool InputIsBitcode) {
+  bool OutputBitcode = ForceOutputBitcode || InputIsBitcode;
+
+  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";
-}
+  } else if (OutputFilename.empty()) {
+    // Default to producing bitcode if the input was bitcode, if not explicitly
+    // requested.
 
-void writeBitcode(ReducerWorkItem &M, llvm::raw_ostream &OutStream) {
-  if (M.LTOInfo && M.LTOInfo->IsThinLTO && M.LTOInfo->EnableSplitLTOUnit) {
-    PassBuilder PB;
-    LoopAnalysisManager LAM;
-    FunctionAnalysisManager FAM;
-    CGSCCAnalysisManager CGAM;
-    ModuleAnalysisManager MAM;
-    PB.registerModuleAnalyses(MAM);
-    PB.registerCGSCCAnalyses(CGAM);
-    PB.registerFunctionAnalyses(FAM);
-    PB.registerLoopAnalyses(LAM);
-    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
-    ModulePassManager MPM;
-    MPM.addPass(ThinLTOBitcodeWriterPass(OutStream, nullptr));
-    MPM.run(*M.M, MAM);
-  } 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());
+    OutputFilename =
+        IsMIR ? "reduced.mir" : (OutputBitcode ? "reduced.bc" : "reduced.ll");
   }
+
+  return {OutputFilename, OutputBitcode};
 }
 
 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);
   }
int main(int Argc, char **Argv) {
 
   if (PrintDeltaPasses) {
     printDeltaPasses(errs());
     return 0;
   }
 
   LLVMContext Context;
   std::unique_ptr<TargetMachine> TM;
+  bool InputIsBitcode = false;
 
-  std::unique_ptr<ReducerWorkItem> OriginalProgram =
-      parseReducerWorkItem(Argv[0], InputFilename, Context, TM, ReduceModeMIR);
+  std::unique_ptr<ReducerWorkItem> OriginalProgram = parseReducerWorkItem(
+      Argv[0], InputFilename, Context, TM, ReduceModeMIR, InputIsBitcode);
   if (!OriginalProgram) {
     return 1;
   }
 
+  StringRef OutputFilename;
+  bool OutputBitcode;
+  std::tie(OutputFilename, OutputBitcode) =
+      determineOutputType(ReduceModeMIR, InputIsBitcode);
+
   // Initialize test environment
   TestRunner Tester(TestFilename, TestArguments, std::move(OriginalProgram),
-                    std::move(TM), Argv[0]);
+                    std::move(TM), Argv[0], OutputFilename, OutputBitcode);
 
   // This parses and writes out the testcase into a temporary file copy for the
   // test, rather than evaluating the source IR directly. This is for the
   // convenience of lit tests; the stripped out comments may have broken the
   // interestingness checks.
   if (!isReduced(Tester.getProgram(), Tester)) {
     errs() << "\nInput isn't interesting! Verify interesting-ness test\n";
     return 1;
   }
 
   // Try to reduce code
   runDeltaPasses(Tester, MaxPassIterations);
 
   // Print reduced file to STDOUT
   if (OutputFilename == "-")
     Tester.getProgram().print(outs(), nullptr);
   else
-    writeOutput(Tester.getProgram(), "Done reducing! Reduced testcase: ");
+    Tester.writeOutput("Done reducing! Reduced testcase: ");
 
   return 0;
 }