llvm-reduce: Reorganize some function locations

[arsenm]

Summary

Move things that are naturally methods of ReducerWorkItem to
be methods of ReducerWorkItem in the same source file.

[arsenm]

Missed isReduced

[aeubanks]

seems reasonable

[arsenm]

592536a9ec9318852c133b3392f2e271a08b0c68

llvm/tools/llvm-reduce/ReducerWorkItem.h

 #define LLVM_TOOLS_LLVM_REDUCE_REDUCERWORKITEM_H
 
 #include "llvm/IR/Module.h"
 #include <memory>
 
 namespace llvm {
 class LLVMContext;
 class MachineModuleInfo;
+class MemoryBufferRef;
 class raw_ostream;
 class TargetMachine;
 class TestRunner;
 struct BitcodeLTOInfo;
 
 class ReducerWorkItem {
 public:
   std::shared_ptr<Module> M;
   std::unique_ptr<BitcodeLTOInfo> LTOInfo;
   std::unique_ptr<MachineModuleInfo> MMI;
 
+  ReducerWorkItem();
+  ~ReducerWorkItem();
+  ReducerWorkItem(ReducerWorkItem &) = delete;
+  ReducerWorkItem(ReducerWorkItem &&) = default;
+
   bool isMIR() const { return MMI != nullptr; }
 
   LLVMContext &getContext() {
     return M->getContext();
   }
 
   Module &getModule() { return *M; }
   const Module &getModule() const { return *M; }
+  operator Module &() const { return *M; }
 
   void print(raw_ostream &ROS, void *p = nullptr) const;
-  operator Module &() const { return *M; }
+  bool verify(raw_fd_ostream *OS) const;
+  std::unique_ptr<ReducerWorkItem> clone(const TargetMachine *TM) const;
 
   /// Return a number to indicate whether there was any reduction progress.
   uint64_t getComplexityScore() const {
     return isMIR() ? computeMIRComplexityScore() : computeIRComplexityScore();
   }
 
-  ReducerWorkItem();
-  ~ReducerWorkItem();
-  ReducerWorkItem(ReducerWorkItem&) = delete;
-  ReducerWorkItem(ReducerWorkItem&&) = default;
+  void writeOutput(raw_ostream &OS, bool EmitBitcode) const;
+  void readBitcode(MemoryBufferRef Data, LLVMContext &Ctx, StringRef ToolName);
+  void writeBitcode(raw_ostream &OutStream) const;
+
+  bool isReduced(const TestRunner &Test) const;
 
 private:
   uint64_t computeIRComplexityScore() const;
   uint64_t computeMIRComplexityScore() const;
 };
-} // namespace llvm
-
-std::pair<std::unique_ptr<llvm::ReducerWorkItem>, bool>
-parseReducerWorkItem(llvm::StringRef ToolName, llvm::StringRef Filename,
-                     llvm::LLVMContext &Ctxt,
-                     std::unique_ptr<llvm::TargetMachine> &TM, bool IsMIR);
-
-std::unique_ptr<llvm::ReducerWorkItem>
-cloneReducerWorkItem(const llvm::ReducerWorkItem &MMM,
-                     const llvm::TargetMachine *TM);
 
-bool verifyReducerWorkItem(const llvm::ReducerWorkItem &MMM,
-                           llvm::raw_fd_ostream *OS);
+std::pair<std::unique_ptr<ReducerWorkItem>, bool>
+parseReducerWorkItem(StringRef ToolName, StringRef Filename, LLVMContext &Ctxt,
+                     std::unique_ptr<TargetMachine> &TM, bool IsMIR);
+} // namespace llvm
 
 #endif

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 "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/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/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/TargetRegistry.h"
+#include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include <optional>
 
 using namespace llvm;
 
 ReducerWorkItem::ReducerWorkItem() = default;
 ReducerWorkItem::~ReducerWorkItem() = default;
 
 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,
-                 StringRef ToolName);
+static cl::opt<bool> TmpFilesAsBitcode(
+    "write-tmp-files-as-bitcode",
+    cl::desc("Always write temporary files as bitcode instead of textual IR"),
+    cl::init(false), cl::cat(LLVMReduceOptions));
 
 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());

 
 static void initializeTargetInfo() {
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 }
 
-std::pair<std::unique_ptr<ReducerWorkItem>, bool>
-parseReducerWorkItem(StringRef ToolName, StringRef Filename, LLVMContext &Ctxt,
-                     std::unique_ptr<TargetMachine> &TM, bool IsMIR) {
-  bool IsBitcode = false;
-  Triple TheTriple;
+void ReducerWorkItem::print(raw_ostream &ROS, void *p) const {
+  if (MMI) {
+    printMIR(ROS, *M);
+    for (Function &F : *M) {
+      if (auto *MF = MMI->getMachineFunction(F))
+        printMIR(ROS, *MF);
+    }
+  } else {
+    M->print(ROS, /*AssemblyAnnotationWriter=*/nullptr,
+             /*ShouldPreserveUseListOrder=*/true);
+  }
+}
 
-  auto MMM = std::make_unique<ReducerWorkItem>();
+bool ReducerWorkItem::verify(raw_fd_ostream *OS) const {
+  if (verifyModule(*M, OS))
+    return true;
 
-  if (IsMIR) {
-    initializeTargetInfo();
+  if (!MMI)
+    return false;
 
-    auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
-    if (std::error_code EC = FileOrErr.getError()) {
-      WithColor::error(errs(), ToolName) << EC.message() << '\n';
-      return {nullptr, false};
-    }
+  for (const Function &F : getModule()) {
+    if (const MachineFunction *MF = MMI->getMachineFunction(F)) {
+      if (!MF->verify(nullptr, "", /*AbortOnError=*/false))
+        return true;
+    }
 
-    std::unique_ptr<MIRParser> MParser =
-        createMIRParser(std::move(FileOrErr.get()), Ctxt);
+  return false;
+}
 
-    auto SetDataLayout = [&](StringRef DataLayoutTargetTriple,
-                             StringRef OldDLStr) -> std::optional<std::string> {
-      // If we are supposed to override the target triple, do so now.
-      std::string IRTargetTriple = DataLayoutTargetTriple.str();
-      if (!TargetTriple.empty())
-        IRTargetTriple = Triple::normalize(TargetTriple);
-      TheTriple = Triple(IRTargetTriple);
-      if (TheTriple.getTriple().empty())
-        TheTriple.setTriple(sys::getDefaultTargetTriple());
+bool ReducerWorkItem::isReduced(const TestRunner &Test) const {
+  const bool UseBitcode = Test.inputIsBitcode() || TmpFilesAsBitcode;
 
-      std::string Error;
-      const Target *TheTarget =
-          TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
-      if (!TheTarget) {
-        WithColor::error(errs(), ToolName) << Error;
-        exit(1);
-      }
+  SmallString<128> CurrentFilepath;
+
+  // Write ReducerWorkItem to tmp file
+  int FD;
+  std::error_code EC = sys::fs::createTemporaryFile(
+      "llvm-reduce", isMIR() ? "mir" : (UseBitcode ? "bc" : "ll"), FD,
+      CurrentFilepath,
+      UseBitcode && !isMIR() ? sys::fs::OF_None : sys::fs::OF_Text);
+  if (EC) {
+    errs() << "Error making unique filename: " << EC.message() << "!\n";
 
-      // Hopefully the MIR parsing doesn't depend on any options.
-      TargetOptions Options;
-      std::optional<Reloc::Model> RM = codegen::getExplicitRelocModel();
-      std::string CPUStr = codegen::getCPUStr();
-      std::string FeaturesStr = codegen::getFeaturesStr();
-      TM = std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
-          TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM,
-          codegen::getExplicitCodeModel(), CodeGenOpt::Default));
-      assert(TM && "Could not allocate target machine!");
-
-      return TM->createDataLayout().getStringRepresentation();
-    };
+  ToolOutputFile Out(CurrentFilepath, FD);
 
-    std::unique_ptr<Module> M = MParser->parseIRModule(SetDataLayout);
-    LLVMTargetMachine *LLVMTM = static_cast<LLVMTargetMachine *>(TM.get());
+  // FIXME: This should be UseBitcode
+  writeOutput(Out.os(), TmpFilesAsBitcode);
 
-    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, false};
-    }
-
-    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.data(), errs());
-        return {nullptr, false};
-      }
-      MMM->M = std::move(Result);
-    } else {
-      IsBitcode = true;
-      readBitcode(*MMM, MemoryBufferRef(**MB), Ctxt, ToolName);
+  Out.os().close();
+  if (Out.os().has_error()) {
+    errs() << "Error emitting bitcode to file '" << CurrentFilepath
+           << "': " << Out.os().error().message();
+    exit(1);
 
-      if (MMM->LTOInfo->IsThinLTO && MMM->LTOInfo->EnableSplitLTOUnit)
-       initializeTargetInfo();
-    }
-  }
-  if (verifyReducerWorkItem(*MMM, &errs())) {
-    WithColor::error(errs(), ToolName)
-        << Filename << " - input module is broken!\n";
-    return {nullptr, false};
-  }
-  return {std::move(MMM), IsBitcode};
+  // Current Chunks aren't interesting
+  return Test.run(CurrentFilepath);
 }
 
 std::unique_ptr<ReducerWorkItem>
-cloneReducerWorkItem(const ReducerWorkItem &MMM, const TargetMachine *TM) {
+ReducerWorkItem::clone(const TargetMachine *TM) const {
   auto CloneMMM = std::make_unique<ReducerWorkItem>();
   if (TM) {
     // We're assuming the Module IR contents are always unchanged by MIR
     // reductions, and can share it as a constant.
-    CloneMMM->M = MMM.M;
+    CloneMMM->M = M;
 
     // MachineModuleInfo contains a lot of other state used during codegen which
     // we won't be using here, but we should be able to ignore it (although this
     // is pretty ugly).
     const LLVMTargetMachine *LLVMTM =
         static_cast<const LLVMTargetMachine *>(TM);
     CloneMMM->MMI = std::make_unique<MachineModuleInfo>(LLVMTM);
 
-    for (const Function &F : MMM.getModule()) {
-      if (auto *MF = MMM.MMI->getMachineFunction(F))
+    for (const Function &F : getModule()) {
+      if (auto *MF = MMI->getMachineFunction(F))
         CloneMMM->MMI->insertFunction(F, cloneMF(MF, *CloneMMM->MMI));
     }
   } else {
-    CloneMMM->M = CloneModule(*MMM.M);
+    CloneMMM->M = CloneModule(*M);
   }
   return CloneMMM;
 }
 
-bool verifyReducerWorkItem(const ReducerWorkItem &MMM, raw_fd_ostream *OS) {
-  if (verifyModule(*MMM.M, OS))
-    return true;
-
-  if (!MMM.MMI)
-    return false;
-
-  for (const Function &F : MMM.getModule()) {
-    if (const MachineFunction *MF = MMM.MMI->getMachineFunction(F)) {
-      if (!MF->verify(nullptr, "", /*AbortOnError=*/false))
-        return true;
-    }
-  }
-
-  return false;
-}
-
-void ReducerWorkItem::print(raw_ostream &ROS, void *p) const {
-  if (MMI) {
-    printMIR(ROS, *M);
-    for (Function &F : *M) {
-      if (auto *MF = MMI->getMachineFunction(F))
-        printMIR(ROS, *MF);
-    }
-  } else {
-    M->print(ROS, /*AssemblyAnnotationWriter=*/nullptr,
-             /*ShouldPreserveUseListOrder=*/true);
-  }
-}
-
 /// Try to produce some number that indicates a function is getting smaller /
 /// simpler.
 static uint64_t computeMIRComplexityScoreImpl(const MachineFunction &MF) {
   uint64_t Score = 0;
   const MachineFrameInfo &MFI = MF.getFrameInfo();
 
   // Add for stack objects
   Score += MFI.getNumObjects();
uint64_t ReducerWorkItem::computeIRComplexityScore() const {
   for (const GlobalIFunc &GI : M.ifuncs())
     Score += classifyReductivePower(GI.getResolver());
 
   for (const Function &F : M)
     Score += computeIRComplexityScoreImpl(F);
 
   return Score;
 }
+
+void ReducerWorkItem::writeOutput(raw_ostream &OS, bool EmitBitcode) const {
+  // Requesting bitcode emission with mir is nonsense, so just ignore it.
+  if (EmitBitcode && !isMIR())
+    writeBitcode(OS);
+  else
+    print(OS, /*AnnotationWriter=*/nullptr);
+}
+
+void ReducerWorkItem::readBitcode(MemoryBufferRef Data, LLVMContext &Ctx,
+                                  StringRef 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);
+  }
+  LTOInfo = std::make_unique<BitcodeLTOInfo>(*LI);
+  M = std::move(MOrErr.get());
+}
+
+void ReducerWorkItem::writeBitcode(raw_ostream &OutStream) const {
+  if (LTOInfo && LTOInfo->IsThinLTO && 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, MAM);
+  } else {
+    std::unique_ptr<ModuleSummaryIndex> Index;
+    if (LTOInfo && LTOInfo->HasSummary) {
+      ProfileSummaryInfo PSI(*M);
+      Index = std::make_unique<ModuleSummaryIndex>(
+          buildModuleSummaryIndex(*M, nullptr, &PSI));
+    }
+    WriteBitcodeToFile(getModule(), OutStream, Index.get());
+  }
+}
+
+std::pair<std::unique_ptr<ReducerWorkItem>, bool>
+llvm::parseReducerWorkItem(StringRef ToolName, StringRef Filename,
+                           LLVMContext &Ctxt,
+                           std::unique_ptr<TargetMachine> &TM, bool IsMIR) {
+  bool IsBitcode = false;
+  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, false};
+    }
+
+    std::unique_ptr<MIRParser> MParser =
+        createMIRParser(std::move(FileOrErr.get()), Ctxt);
+
+    auto SetDataLayout = [&](StringRef DataLayoutTargetTriple,
+                             StringRef OldDLStr) -> std::optional<std::string> {
+      // If we are supposed to override the target triple, do so now.
+      std::string IRTargetTriple = DataLayoutTargetTriple.str();
+      if (!TargetTriple.empty())
+        IRTargetTriple = Triple::normalize(TargetTriple);
+      TheTriple = Triple(IRTargetTriple);
+      if (TheTriple.getTriple().empty())
+        TheTriple.setTriple(sys::getDefaultTargetTriple());
+
+      std::string Error;
+      const Target *TheTarget =
+          TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
+      if (!TheTarget) {
+        WithColor::error(errs(), ToolName) << Error;
+        exit(1);
+      }
+
+      // Hopefully the MIR parsing doesn't depend on any options.
+      TargetOptions Options;
+      std::optional<Reloc::Model> RM = codegen::getExplicitRelocModel();
+      std::string CPUStr = codegen::getCPUStr();
+      std::string FeaturesStr = codegen::getFeaturesStr();
+      TM = std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
+          TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM,
+          codegen::getExplicitCodeModel(), CodeGenOpt::Default));
+      assert(TM && "Could not allocate target machine!");
+
+      return TM->createDataLayout().getStringRepresentation();
+    };
+
+    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, false};
+    }
+
+    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.data(), errs());
+        return {nullptr, false};
+      }
+      MMM->M = std::move(Result);
+    } else {
+      IsBitcode = true;
+      MMM->readBitcode(MemoryBufferRef(**MB), Ctxt, ToolName);
+
+      if (MMM->LTOInfo->IsThinLTO && MMM->LTOInfo->EnableSplitLTOUnit)
+        initializeTargetInfo();
+    }
+  }
+  if (MMM->verify(&errs())) {
+    WithColor::error(errs(), ToolName)
+        << Filename << " - input module is broken!\n";
+    return {nullptr, false};
+  }
+  return {std::move(MMM), IsBitcode};
+}

llvm/tools/llvm-reduce/TestRunner.h

public:
 
   /// Runs the interesting-ness test for the specified file
   /// @returns 0 if test was successful, 1 if otherwise
   int run(StringRef Filename) const;
 
   /// Returns the most reduced version of the original testcase
   ReducerWorkItem &getProgram() const { return *Program; }
 
-  void setProgram(std::unique_ptr<ReducerWorkItem> P);
+  void setProgram(std::unique_ptr<ReducerWorkItem> &&P) {
+    assert(P && "Setting null program?");
+    Program = std::move(P);
+  }
 
   const TargetMachine *getTargetMachine() const { return TM.get(); }
 
   StringRef getToolName() const { return ToolName; }
 
   void writeOutput(StringRef Message);
 
   bool inputIsBitcode() const {

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/Support/WithColor.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, StringRef ToolName,
                        StringRef OutputName, bool InputIsBitcode,
Error E = make_error<StringError>("Error running interesting-ness test: " +
                                       inconvertibleErrorCode());
     WithColor::error(errs(), ToolName) << toString(std::move(E)) << '\n';
     exit(1);
   }
 
   return !Result;
 }
 
-void TestRunner::setProgram(std::unique_ptr<ReducerWorkItem> P) {
-  assert(P && "Setting null program?");
-  Program = std::move(P);
-}
-
-void writeBitcode(const 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.getModule(), OutStream, Index.get());
-  }
-}
-
 void TestRunner::writeOutput(StringRef Message) {
   std::error_code EC;
   raw_fd_ostream Out(OutputFilename, EC,
                      EmitBitcode && !Program->isMIR() ? sys::fs::OF_None
                                                       : sys::fs::OF_Text);
   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);
-
+  Program->writeOutput(Out, EmitBitcode);
   errs() << Message << OutputFilename << '\n';
 }

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

 // 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.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_DELTA_H
 #define LLVM_TOOLS_LLVM_REDUCE_DELTAS_DELTA_H
 
-#include "TestRunner.h"
+#include "ReducerWorkItem.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/ScopeExit.h"
+#include "llvm/Support/raw_ostream.h"
 #include <functional>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
+class TestRunner;
+
 struct Chunk {
   int Begin;
   int End;
 
   /// Helper function to verify if a given Target-index is inside the Chunk
   bool contains(int Index) const { return Index >= Begin && Index <= End; }
 
   void print() const {

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

 //===- Delta.cpp - Delta Debugging Algorithm Implementation ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the implementation for the Delta Debugging Algorithm:
 // 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 "TestRunner.h"
 #include "Utils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/Analysis/ProfileSummaryInfo.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;
 
 static cl::opt<bool> AbortOnInvalidReduction(
     "abort-on-invalid-reduction",
     cl::desc("Abort if any reduction results in invalid IR"),
     cl::cat(LLVMReduceOptions));
 
 static cl::opt<unsigned int> StartingGranularityLevel(
     "starting-granularity-level",
     cl::desc("Number of times to divide chunks prior to first test"),
     cl::cat(LLVMReduceOptions));
 
-static cl::opt<bool> TmpFilesAsBitcode(
-    "write-tmp-files-as-bitcode",
-    cl::desc("Always write temporary files as bitcode instead of textual IR"),
-    cl::init(false), cl::cat(LLVMReduceOptions));
-
 #ifdef LLVM_ENABLE_THREADS
 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 writeBitcode(const ReducerWorkItem &M, raw_ostream &OutStream);
-
-void readBitcode(ReducerWorkItem &M, MemoryBufferRef Data, LLVMContext &Ctx,
-                 StringRef ToolName);
-
-bool isReduced(const ReducerWorkItem &M, const TestRunner &Test) {
-  const bool UseBitcode = Test.inputIsBitcode() || TmpFilesAsBitcode;
-
-  SmallString<128> CurrentFilepath;
-
-  // Write ReducerWorkItem to tmp file
-  int FD;
-  std::error_code EC = sys::fs::createTemporaryFile(
-      "llvm-reduce", M.isMIR() ? "mir" : (UseBitcode ? "bc" : "ll"), FD,
-      CurrentFilepath,
-      UseBitcode && !M.isMIR() ? sys::fs::OF_None : sys::fs::OF_Text);
-  if (EC) {
-    errs() << "Error making unique filename: " << EC.message() << "!\n";
-    exit(1);
-  }
-
-  ToolOutputFile Out(CurrentFilepath, FD);
-
-  if (TmpFilesAsBitcode)
-    writeBitcode(M, Out.os());
-  else
-    M.print(Out.os(), /*AnnotationWriter=*/nullptr);
-
-  Out.os().close();
-  if (Out.os().has_error()) {
-    errs() << "Error emitting bitcode to file '" << CurrentFilepath
-           << "': " << Out.os().error().message();
-    exit(1);
-  }
-
-  // Current Chunks aren't interesting
-  return Test.run(CurrentFilepath);
-}
-
 /// Splits Chunks in half and prints them.
 /// If unable to split (when chunk size is 1) returns false.
 static bool increaseGranularity(std::vector<Chunk> &Chunks) {
   if (Verbose)
     errs() << "Increasing granularity...";
   std::vector<Chunk> NewChunks;
   bool SplitAny = false;
 
copy_if(ChunksStillConsideredInteresting, std::back_inserter(CurrentChunks),
                    !UninterestingChunks.count(C);
           });
 
   // Generate Module with only Targets inside Current Chunks
   Oracle O(CurrentChunks);
   ExtractChunksFromModule(O, *Clone);
 
   // Some reductions may result in invalid IR. Skip such reductions.
-  if (verifyReducerWorkItem(*Clone, &errs())) {
+  if (Clone->verify(&errs())) {
     if (AbortOnInvalidReduction) {
       errs() << "Invalid reduction, aborting.\n";
       Clone->print(errs());
       exit(1);
     }
     if (Verbose) {
       errs() << " **** WARNING | reduction resulted in invalid module, "
                 "skipping\n";
     }
     return nullptr;
   }
 
   if (Verbose) {
     errs() << "Ignoring: ";
     ChunkToCheckForUninterestingness.print();
     for (const Chunk &C : UninterestingChunks)
       C.print();
     errs() << "\n";
   }
 
-  if (!isReduced(*Clone, Test)) {
+  if (!Clone->isReduced(Test)) {
     // Program became non-reduced, so this chunk appears to be interesting.
     if (Verbose)
       errs() << "\n";
     return nullptr;
   }
   return Clone;
 }
 
 static SmallString<0> ProcessChunkFromSerializedBitcode(
     const Chunk ChunkToCheckForUninterestingness, const TestRunner &Test,
     ReductionFunc ExtractChunksFromModule,
     const DenseSet<Chunk> &UninterestingChunks,
     ArrayRef<Chunk> ChunksStillConsideredInteresting, StringRef OriginalBC,
     std::atomic<bool> &AnyReduced) {
   LLVMContext Ctx;
   auto CloneMMM = std::make_unique<ReducerWorkItem>();
   MemoryBufferRef Data(OriginalBC, "<bc file>");
-  readBitcode(*CloneMMM, Data, Ctx, Test.getToolName());
+  CloneMMM->readBitcode(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);
-    writeBitcode(*ChunkResult, BCOS);
+    ChunkResult->writeBitcode(BCOS);
     // Communicate that the task reduced a chunk.
     AnyReduced = true;
   }
   return Result;
 }
 
 using SharedTaskQueue = std::deque<std::shared_future<SmallString<0>>>;
 
 static void waitAndDiscardResultsBarrier(SharedTaskQueue &TaskQueue) {
   while (!TaskQueue.empty()) {
     auto &Future = TaskQueue.front();
     Future.wait();
     TaskQueue.pop_front();
   }
 }
 
 /// Runs the Delta Debugging algorithm, splits the code into chunks and
 /// reduces the amount of chunks that are considered interesting by the
 /// given test. The number of chunks is determined by a preliminary run of the
 /// reduction pass where no change must be made to the module.
 void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
                         StringRef Message) {
-  assert(!verifyReducerWorkItem(Test.getProgram(), &errs()) &&
+  assert(!Test.getProgram().verify(&errs()) &&
          "input module is broken before making changes");
   errs() << "*** " << Message << "...\n";
 
   int Targets;
   {
     // Count the number of chunks by counting the number of calls to
     // Oracle::shouldKeep() but always returning true so no changes are
     // made.
     std::vector<Chunk> AllChunks = {{0, INT_MAX}};
     Oracle Counter(AllChunks);
     ExtractChunksFromModule(Counter, Test.getProgram());
     Targets = Counter.count();
 
-    assert(!verifyReducerWorkItem(Test.getProgram(), &errs()) &&
+    assert(!Test.getProgram().verify(&errs()) &&
            "input module is broken after counting chunks");
-    assert(isReduced(Test.getProgram(), Test) &&
+    assert(Test.getProgram().isReduced(Test) &&
            "input module no longer interesting after counting chunks");
 
 #ifndef NDEBUG
     {
       // Make sure that the number of chunks does not change as we reduce.
       std::vector<Chunk> NoChunks = {{0, INT_MAX}};
       Oracle NoChunksCounter(NoChunks);
       std::unique_ptr<ReducerWorkItem> Clone =
-        cloneReducerWorkItem(Test.getProgram(), Test.getTargetMachine());
+          Test.getProgram().clone(Test.getTargetMachine());
       ExtractChunksFromModule(NoChunksCounter, *Clone);
       assert(Targets == NoChunksCounter.count() &&
              "number of chunks changes when reducing");
     }
 #endif
   }
   if (!Targets) {
     if (Verbose)
do {
 
     DenseSet<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);
-      writeBitcode(Test.getProgram(), BCOS);
+      Test.getProgram().writeBitcode(BCOS);
     }
 
     SharedTaskQueue 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(),
                   ChunksStillConsideredInteresting, OriginalBC,
                   std::ref(AnyReduced)));
             }
             continue;
           }
 
           Result = std::make_unique<ReducerWorkItem>();
           MemoryBufferRef Data(StringRef(Res), "<bc file>");
-          readBitcode(*Result, Data, Test.getProgram().M->getContext(),
+          Result->readBitcode(Data, Test.getProgram().M->getContext(),
                               Test.getToolName());
           break;
         }
 
         // If we broke out of the loop, we still need to wait for everything to
         // avoid race access to the chunk set.
         //
         // TODO: Create a way to kill remaining items we're ignoring; they could
         // take a long time.
         waitAndDiscardResultsBarrier(TaskQueue);
 
         // Forward I to the last chunk processed in parallel.
         I += NumChunksProcessed - 1;
       } else {
-        Result = CheckChunk(
-            *I,
-            cloneReducerWorkItem(Test.getProgram(), Test.getTargetMachine()),
+        Result =
+            CheckChunk(*I, Test.getProgram().clone(Test.getTargetMachine()),
                        Test, ExtractChunksFromModule, UninterestingChunks,
                        ChunksStillConsideredInteresting);
       }
 
       if (!Result)
         continue;
 
       const Chunk ChunkToCheckForUninterestingness = *I;
       FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = true;
       UninterestingChunks.insert(ChunkToCheckForUninterestingness);

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

 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(const ReducerWorkItem &M, const TestRunner &Test);
-
 /// Turn off crash debugging features
 ///
 /// Crash is expected, so disable crash reports and symbolization to reduce
 /// output clutter and avoid potentially slow symbolization.
 static void disableEnvironmentDebugFeatures() {
   sys::Process::PreventCoreFiles();
 
   // TODO: Copied from not. Should have a wrapper around setenv.
if (ReplaceInput) { // In-place
 
     OutputFilename =
         IsMIR ? "reduced.mir" : (OutputBitcode ? "reduced.bc" : "reduced.ll");
   }
 
   return {OutputFilename, OutputBitcode};
 }
 
-void readBitcode(ReducerWorkItem &M, MemoryBufferRef Data, LLVMContext &Ctx,
-                 StringRef 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);
   const StringRef ToolName(Argv[0]);
 
   cl::HideUnrelatedOptions({&LLVMReduceOptions, &getColorCategory()});
   cl::ParseCommandLineOptions(Argc, Argv, "LLVM automatic testcase reducer.\n");
 
   if (Argc == 1) {
int main(int Argc, char **Argv) {
   TestRunner Tester(TestFilename, TestArguments, std::move(OriginalProgram),
                     std::move(TM), ToolName, OutputFilename, InputIsBitcode,
                     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)) {
+  if (!Tester.getProgram().isReduced(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
     Tester.writeOutput("Done reducing! Reduced testcase: ");
 
   return 0;
 }