[NFC][llvm-reduce] Cleanup types

[aeubanks]

Summary

Use Module& wherever possible.
Since every reduction immediately turns Chunks into an Oracle, directly pass Oracle instead.

[Meinersbur]

std::vector<Chunk> -> Oracle: LGTM

Module* -> Module&: It's a code style question and I prefer using Module* (or wrapped in a smart pointer) consistently. I don't like that sometimes it's M. but sometimes M->. It also makes "Has TestRunner been assigned a Program yet?" undefined behaviour.

There are some comment reflows. I assume this is due to adding a new scope, clang-format, removing the scope, clang-format again. Could you clean that up?

[aeubanks]

undo comment reformatting
we should never have a null Module, added asserts for that and changed the constructor to force an initial Module
I prefer Module& to show that it can never be null

llvm/tools/llvm-reduce/TestRunner.h

 
 namespace llvm {
 
 // 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);
+  TestRunner(StringRef TestName, const std::vector<std::string> &TestArgs,
+             std::unique_ptr<Module> Program);
 
   /// 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
-  Module *getProgram() const { return Program.get(); }
+  Module &getProgram() const { return *Program; }
 
-  void setProgram(std::unique_ptr<Module> P) { Program = std::move(P); }
+  void setProgram(std::unique_ptr<Module> P) {
+    assert(P && "Setting null program?");
+    Program = std::move(P);
+  }
 
 private:
   StringRef TestName;
   const std::vector<std::string> &TestArgs;
   std::unique_ptr<Module> Program;
 };
 
 } // 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"
 
 using namespace llvm;
 
-TestRunner::TestRunner(StringRef TestName, const std::vector<std::string> &TestArgs)
-    : TestName(TestName), TestArgs(TestArgs) {
+TestRunner::TestRunner(StringRef TestName,
+                       const std::vector<std::string> &TestArgs,
+                       std::unique_ptr<Module> Program)
+    : TestName(TestName), TestArgs(TestArgs), Program(std::move(Program)) {
+  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.h

 /// algorithm, for example, the RemoveGlobalVars pass would send the amount of
 /// initialized GVs.
 /// * ExtractChunksFromModule: A function used to tailor the main program so it
 /// only contains Targets that are inside Chunks of the given iteration.
 /// Note: This function is implemented by each specialized Delta pass
 ///
 /// Other implementations of the Delta Debugging algorithm can also be found in
 /// the CReduce, Delta, and Lithium projects.
-void runDeltaPass(TestRunner &Test, int Targets,
-                  std::function<void(const std::vector<Chunk> &, Module *)>
-                      ExtractChunksFromModule);
+void runDeltaPass(
+    TestRunner &Test, int Targets,
+    function_ref<void(Oracle &, Module &)> ExtractChunksFromModule);
 } // namespace llvm
 
 #endif

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

 #include <set>
 
 using namespace llvm;
 
 static cl::opt<bool> AbortOnInvalidReduction(
     "abort-on-invalid-reduction",
     cl::desc("Abort if any reduction results in invalid IR"));
 
-void writeOutput(llvm::Module *M, llvm::StringRef Message);
+void writeOutput(llvm::Module &M, llvm::StringRef Message);
 
 bool isReduced(Module &M, TestRunner &Test, SmallString<128> &CurrentFilepath) {
   // Write Module to tmp file
   int FD;
   std::error_code EC =
       sys::fs::createTemporaryFile("llvm-reduce", "ll", FD, CurrentFilepath);
   if (EC) {
     errs() << "Error making unique filename: " << EC.message() << "!\n";
static bool increaseGranularity(std::vector<Chunk> &Chunks) {
   return SplitOne;
 }
 
 /// Runs the Delta Debugging algorithm, splits the code into chunks and
 /// reduces the amount of chunks that are considered interesting by the
 /// given test.
 void llvm::runDeltaPass(
     TestRunner &Test, int Targets,
-    std::function<void(const std::vector<Chunk> &, Module *)>
-        ExtractChunksFromModule) {
+    function_ref<void(Oracle &, Module &)> ExtractChunksFromModule) {
   assert(Targets >= 0);
   if (!Targets) {
     errs() << "\nNothing to reduce\n";
     return;
   }
 
-  if (Module *Program = Test.getProgram()) {
-    SmallString<128> CurrentFilepath;
-    if (!isReduced(*Program, Test, CurrentFilepath)) {
-      errs() << "\nInput isn't interesting! Verify interesting-ness test\n";
-      exit(1);
-    }
+  if (!isReduced(Test.getProgram(), Test, CurrentFilepath)) {
 
-    assert(!verifyModule(*Program, &errs()) &&
-           "input module is broken before making changes");
-  }
+  assert(!verifyModule(Test.getProgram(), &errs()) &&
 
   std::vector<Chunk> ChunksStillConsideredInteresting = {{1, Targets}};
   std::unique_ptr<Module> ReducedProgram;
 
   bool FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity;
   do {
     FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = false;
 
for (Chunk &ChunkToCheckForUninterestingness :
                             UninterestingChunks.size() - 1);
       copy_if(ChunksStillConsideredInteresting,
               std::back_inserter(CurrentChunks), [&](const Chunk &C) {
                 return !UninterestingChunks.count(C) &&
                        C != ChunkToCheckForUninterestingness;
               });
 
       // Clone module before hacking it up..
-      std::unique_ptr<Module> Clone = CloneModule(*Test.getProgram());
+      std::unique_ptr<Module> Clone = CloneModule(Test.getProgram());
       // Generate Module with only Targets inside Current Chunks
-      ExtractChunksFromModule(CurrentChunks, Clone.get());
+      Oracle O(CurrentChunks);
+      ExtractChunksFromModule(O, *Clone);
 
       // Some reductions may result in invalid IR. Skip such reductions.
-      if (verifyModule(*Clone.get(), &errs())) {
+      if (verifyModule(*Clone, &errs())) {
         if (AbortOnInvalidReduction) {
           errs() << "Invalid reduction\n";
           exit(1);
         }
         errs() << " **** WARNING | reduction resulted in invalid module, "
                   "skipping\n";
         continue;
       }
for (Chunk &ChunkToCheckForUninterestingness :
         errs() << "\n";
         continue;
       }
 
       FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = true;
       UninterestingChunks.insert(ChunkToCheckForUninterestingness);
       ReducedProgram = std::move(Clone);
       errs() << " **** SUCCESS | lines: " << getLines(CurrentFilepath) << "\n";
-      writeOutput(ReducedProgram.get(), "Saved new best reduction to ");
+      writeOutput(*ReducedProgram, "Saved new best reduction to ");
     }
     // Delete uninteresting chunks
     erase_if(ChunksStillConsideredInteresting,
              [&UninterestingChunks](const Chunk &C) {
                return UninterestingChunks.count(C);
              });
   } while (!ChunksStillConsideredInteresting.empty() &&
            (FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity ||
             increaseGranularity(ChunksStillConsideredInteresting)));
 
   // If we reduced the testcase replace it
   if (ReducedProgram)
     Test.setProgram(std::move(ReducedProgram));
   errs() << "Couldn't increase anymore.\n";
 }

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

 #include "Delta.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/GlobalValue.h"
 
 using namespace llvm;
 
 /// Removes all aliases aren't inside any of the
 /// desired Chunks.
-static void extractAliasesFromModule(const std::vector<Chunk> &ChunksToKeep,
-                                     Module *Program) {
-  Oracle O(ChunksToKeep);
-
-  for (auto &GA : make_early_inc_range(Program->aliases())) {
+static void extractAliasesFromModule(Oracle &O, Module &Program) {
+  for (auto &GA : make_early_inc_range(Program.aliases())) {
     if (!O.shouldKeep()) {
       GA.replaceAllUsesWith(GA.getAliasee());
       GA.eraseFromParent();
     }
   }
 }
 
 /// Counts the amount of aliases and prints their respective name & index.
-static int countAliases(Module *Program) {
+static int countAliases(Module &Program) {
   // TODO: Silence index with --quiet flag
   errs() << "----------------------------\n";
   errs() << "Aliases Index Reference:\n";
   int Count = 0;
-  for (auto &GA : Program->aliases())
+  for (auto &GA : Program.aliases())
     errs() << "\t" << ++Count << ": " << GA.getName() << "\n";
 
   errs() << "----------------------------\n";
   return Count;
 }
 
 void llvm::reduceAliasesDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Aliases ...\n";
   int Functions = countAliases(Test.getProgram());
   runDeltaPass(Test, Functions, extractAliasesFromModule);
   errs() << "----------------------------\n";
 }

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

 /// not considered. Intrinsics aren't considered because their signatures are
 /// fixed.
 static bool shouldRemoveArguments(const Function &F) {
   return !F.arg_empty() && !F.isIntrinsic();
 }
 
 /// Removes out-of-chunk arguments from functions, and modifies their calls
 /// accordingly. It also removes allocations of out-of-chunk arguments.
-static void extractArgumentsFromModule(std::vector<Chunk> ChunksToKeep,
-                                       Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractArgumentsFromModule(Oracle &O, Module &Program) {
   std::set<Argument *> ArgsToKeep;
   std::vector<Function *> Funcs;
   // Get inside-chunk arguments, as well as their parent function
-  for (auto &F : *Program)
+  for (auto &F : Program)
     if (shouldRemoveArguments(F)) {
       Funcs.push_back(&F);
       for (auto &A : F.args())
         if (O.shouldKeep())
           ArgsToKeep.insert(&A);
     }
 
   for (auto *F : Funcs) {
for (auto *F : Funcs) {
     std::set<int> ArgIndexesToKeep;
     for (auto &Arg : enumerate(F->args()))
       if (ArgsToKeep.count(&Arg.value()))
         ArgIndexesToKeep.insert(Arg.index());
 
     auto *ClonedFunc = CloneFunction(F, VMap);
     // In order to preserve function order, we move Clone after old Function
     ClonedFunc->removeFromParent();
-    Program->getFunctionList().insertAfter(F->getIterator(), ClonedFunc);
+    Program.getFunctionList().insertAfter(F->getIterator(), ClonedFunc);
 
     replaceFunctionCalls(*F, *ClonedFunc, ArgIndexesToKeep);
     // Rename Cloned Function to Old's name
     std::string FName = std::string(F->getName());
     F->replaceAllUsesWith(ConstantExpr::getBitCast(ClonedFunc, F->getType()));
     F->eraseFromParent();
     ClonedFunc->setName(FName);
   }
 }
 
 /// Counts the amount of arguments in functions and prints their respective
 /// name, index, and parent function name
-static int countArguments(Module *Program) {
+static int countArguments(Module &Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   outs() << "Param Index Reference:\n";
   int ArgsCount = 0;
-  for (auto &F : *Program)
+  for (auto &F : Program)
     if (shouldRemoveArguments(F)) {
       outs() << "  " << F.getName() << "\n";
       for (auto &A : F.args())
         outs() << "\t" << ++ArgsCount << ": " << A.getName() << "\n";
 
       outs() << "----------------------------\n";
     }
 
   return ArgsCount;
 }
 
 void llvm::reduceArgumentsDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Arguments...\n";
   int ArgCount = countArguments(Test.getProgram());
   runDeltaPass(Test, ArgCount, extractArgumentsFromModule);
 }

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

 
 using AttrPtrVecTy = std::vector<const Attribute *>;
 using AttrPtrIdxVecVecTy = std::pair<unsigned, AttrPtrVecTy>;
 using AttrPtrVecVecTy = SmallVector<AttrPtrIdxVecVecTy, 3>;
 
 /// Given ChunksToKeep, produce a map of global variables/functions/calls
 /// and indexes of attributes to be preserved for each of them.
 class AttributeRemapper : public InstVisitor<AttributeRemapper> {
-  Oracle O;
+  Oracle &O;
 
 public:
   DenseMap<GlobalVariable *, AttrPtrVecTy> GlobalVariablesToRefine;
   DenseMap<Function *, AttrPtrVecVecTy> FunctionsToRefine;
   DenseMap<CallBase *, AttrPtrVecVecTy> CallsToRefine;
 
-  explicit AttributeRemapper(ArrayRef<Chunk> ChunksToKeep) : O(ChunksToKeep) {}
+  explicit AttributeRemapper(Oracle &O) : O(O) {}
 
   void visitModule(Module &M) {
     for (GlobalVariable &GV : M.getGlobalList())
       visitGlobalVariable(GV);
   }
 
   void visitGlobalVariable(GlobalVariable &GV) {
     // Global variables only have one attribute set.
sort(SetVec, [](const std::pair<unsigned, AttributeSet> &LHS,
                   const std::pair<unsigned, AttributeSet> &RHS) {
     return LHS.first < RHS.first; // All values are unique.
   });
 
   return AttributeList::get(C, SetVec);
 }
 
 /// Removes out-of-chunk attributes from module.
-static void extractAttributesFromModule(std::vector<Chunk> ChunksToKeep,
-                                        Module *Program) {
-  AttributeRemapper R(ChunksToKeep);
+static void extractAttributesFromModule(Oracle &O, Module &Program) {
+  AttributeRemapper R(O);
   R.visit(Program);
 
-  LLVMContext &C = Program->getContext();
+  LLVMContext &C = Program.getContext();
   for (const auto &I : R.GlobalVariablesToRefine)
     I.first->setAttributes(convertAttributeRefToAttributeSet(C, I.second));
   for (const auto &I : R.FunctionsToRefine)
     I.first->setAttributes(convertAttributeRefVecToAttributeList(C, I.second));
   for (const auto &I : R.CallsToRefine)
     I.first->setAttributes(convertAttributeRefVecToAttributeList(C, I.second));
 }
 
 /// Counts the amount of attributes.
-static int countAttributes(Module *Program) {
+static int countAttributes(Module &Program) {
   AttributeCounter C;
 
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   C.visit(Program);
   outs() << "Number of attributes: " << C.AttributeCount << "\n";
 
   return C.AttributeCount;
 }
 
 void llvm::reduceAttributesDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Attributes...\n";
   int AttributeCount = countAttributes(Test.getProgram());
   runDeltaPass(Test, AttributeCount, extractAttributesFromModule);
 }

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

for (int I = 0, E = SwInst.getNumCases(); I != E; ++I) {
         --I;
         --E;
       }
     }
 }
 
 /// Removes out-of-chunk arguments from functions, and modifies their calls
 /// accordingly. It also removes allocations of out-of-chunk arguments.
-static void extractBasicBlocksFromModule(std::vector<Chunk> ChunksToKeep,
-                                         Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractBasicBlocksFromModule(Oracle &O, Module &Program) {
   std::set<BasicBlock *> BBsToKeep;
 
-  for (auto &F : *Program)
+  for (auto &F : Program)
     for (auto &BB : F)
       if (O.shouldKeep())
         BBsToKeep.insert(&BB);
 
   std::vector<BasicBlock *> BBsToDelete;
-  for (auto &F : *Program)
+  for (auto &F : Program)
     for (auto &BB : F) {
       if (!BBsToKeep.count(&BB)) {
         BBsToDelete.push_back(&BB);
         // Remove out-of-chunk BB from successor phi nodes
         for (auto *Succ : successors(&BB))
           Succ->removePredecessor(&BB);
       }
     }
 
   // Replace terminators that reference out-of-chunk BBs
-  for (auto &F : *Program)
+  for (auto &F : Program)
     for (auto &BB : F) {
       if (auto *SwInst = dyn_cast<SwitchInst>(BB.getTerminator()))
         removeUninterestingBBsFromSwitch(*SwInst, BBsToKeep);
       else
         replaceBranchTerminator(BB, BBsToKeep);
     }
 
   // Replace out-of-chunk switch uses
   for (auto &BB : BBsToDelete) {
     // Instructions might be referenced in other BBs
     for (auto &I : *BB)
       I.replaceAllUsesWith(UndefValue::get(I.getType()));
     BB->eraseFromParent();
   }
 }
 
 /// Counts the amount of basic blocks and prints their name & respective index
-static int countBasicBlocks(Module *Program) {
+static int countBasicBlocks(Module &Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   int BBCount = 0;
-  for (auto &F : *Program)
+  for (auto &F : Program)
     for (auto &BB : F) {
       if (BB.hasName())
         outs() << "\t" << ++BBCount << ": " << BB.getName() << "\n";
       else
         outs() << "\t" << ++BBCount << ": Unnamed\n";
     }
 
   return BBCount;
 }
 
 void llvm::reduceBasicBlocksDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Basic Blocks...\n";
   int BBCount = countBasicBlocks(Test.getProgram());
   runDeltaPass(Test, BBCount, extractBasicBlocksFromModule);
 }

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

 #include "ReduceFunctionBodies.h"
 #include "Delta.h"
 #include "llvm/IR/GlobalValue.h"
 
 using namespace llvm;
 
 /// Removes all the bodies of defined functions that aren't inside any of the
 /// desired Chunks.
-static void
-extractFunctionBodiesFromModule(const std::vector<Chunk> &ChunksToKeep,
-                                Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractFunctionBodiesFromModule(Oracle &O, Module &Program) {
   // Delete out-of-chunk function bodies
   std::vector<Function *> FuncDefsToReduce;
-  for (auto &F : *Program)
+  for (auto &F : Program)
     if (!F.isDeclaration() && !O.shouldKeep()) {
       F.deleteBody();
       F.setComdat(nullptr);
     }
 }
 
 /// Counts the amount of non-declaration functions and prints their
 /// respective name & index
-static int countFunctionDefinitions(Module *Program) {
+static int countFunctionDefinitions(Module &Program) {
   // TODO: Silence index with --quiet flag
   errs() << "----------------------------\n";
   errs() << "Function Definition Index Reference:\n";
   int FunctionDefinitionCount = 0;
-  for (auto &F : *Program)
+  for (auto &F : Program)
     if (!F.isDeclaration())
       errs() << "\t" << ++FunctionDefinitionCount << ": " << F.getName()
              << "\n";
 
   errs() << "----------------------------\n";
   return FunctionDefinitionCount;
 }
 
 void llvm::reduceFunctionBodiesDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Function Bodies...\n";
   int Functions = countFunctionDefinitions(Test.getProgram());
   runDeltaPass(Test, Functions, extractFunctionBodiesFromModule);
   errs() << "----------------------------\n";
 }

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

 #include "llvm/IR/Instructions.h"
 #include <iterator>
 #include <vector>
 
 using namespace llvm;
 
 /// Removes all the Defined Functions
 /// that aren't inside any of the desired Chunks.
-static void extractFunctionsFromModule(const std::vector<Chunk> &ChunksToKeep,
-                                       Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractFunctionsFromModule(Oracle &O, Module &Program) {
   // Record all out-of-chunk functions.
   std::vector<std::reference_wrapper<Function>> FuncsToRemove;
-  copy_if(Program->functions(), std::back_inserter(FuncsToRemove),
+  copy_if(Program.functions(), std::back_inserter(FuncsToRemove),
           [&O](Function &F) {
             // Intrinsics don't have function bodies that are useful to
             // reduce. Additionally, intrinsics may have additional operand
             // constraints. But, do drop intrinsics that are not referenced.
             return (!F.isIntrinsic() || F.use_empty()) && !O.shouldKeep();
           });
 
   // Then, drop body of each of them. We want to batch this and do nothing else
   // here so that minimal number of remaining exteranal uses will remain.
   for (Function &F : FuncsToRemove)
     F.dropAllReferences();
 
   // And finally, we can actually delete them.
   for (Function &F : FuncsToRemove) {
     // Replace all *still* remaining uses with undef.
     F.replaceAllUsesWith(UndefValue::get(F.getType()));
     // And finally, fully drop it.
     F.eraseFromParent();
   }
 }
 
 /// Counts the amount of functions and prints their
 /// respective name & index
-static int countFunctions(Module *Program) {
+static int countFunctions(Module &Program) {
   // TODO: Silence index with --quiet flag
   errs() << "----------------------------\n";
   errs() << "Function Index Reference:\n";
   int FunctionCount = 0;
-  for (auto &F : *Program) {
+  for (auto &F : Program) {
     if (F.isIntrinsic() && !F.use_empty())
       continue;
 
     errs() << '\t' << ++FunctionCount << ": " << F.getName() << '\n';
   }
 
   errs() << "----------------------------\n";
   return FunctionCount;
 }
 
 void llvm::reduceFunctionsDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Functions...\n";
   int Functions = countFunctions(Test.getProgram());
   runDeltaPass(Test, Functions, extractFunctionsFromModule);
   errs() << "----------------------------\n";
 }

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

 
 using namespace llvm;
 
 static bool isValidDSOLocalReductionGV(GlobalValue &GV) {
   return GV.isDSOLocal() && !GV.isImplicitDSOLocal();
 }
 
 /// Sets dso_local to false for all global values.
-static void extractGVsFromModule(std::vector<Chunk> ChunksToKeep,
-                                 Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractGVsFromModule(Oracle &O, Module &Program) {
   // remove dso_local from global values
-  for (auto &GV : Program->global_values())
+  for (auto &GV : Program.global_values())
     if (isValidDSOLocalReductionGV(GV) && !O.shouldKeep()) {
       GV.setDSOLocal(false);
     }
 }
 
 /// Counts the amount of global values with dso_local and displays their
 /// respective name & index
-static int countGVs(Module *Program) {
+static int countGVs(Module &Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   outs() << "GlobalValue Index Reference:\n";
   int GVCount = 0;
-  for (auto &GV : Program->global_values())
+  for (auto &GV : Program.global_values())
     if (isValidDSOLocalReductionGV(GV))
       outs() << "\t" << ++GVCount << ": " << GV.getName() << "\n";
   outs() << "----------------------------\n";
   return GVCount;
 }
 
 void llvm::reduceGlobalValuesDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing GlobalValues...\n";
   int GVCount = countGVs(Test.getProgram());
   runDeltaPass(Test, GVCount, extractGVsFromModule);
 }

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

 
 #include "ReduceGlobalVarInitializers.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/GlobalValue.h"
 
 using namespace llvm;
 
 /// Removes all the Initialized GVs that aren't inside the desired Chunks.
-static void extractGVsFromModule(std::vector<Chunk> ChunksToKeep,
-                                 Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractGVsFromModule(Oracle &O, Module &Program) {
   // Drop initializers of out-of-chunk GVs
-  for (auto &GV : Program->globals())
+  for (auto &GV : Program.globals())
     if (GV.hasInitializer() && !O.shouldKeep()) {
       GV.setInitializer(nullptr);
       GV.setLinkage(GlobalValue::LinkageTypes::ExternalLinkage);
       GV.setComdat(nullptr);
     }
 }
 
 /// Counts the amount of initialized GVs and displays their
 /// respective name & index
-static int countGVs(Module *Program) {
+static int countGVs(Module &Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   outs() << "GlobalVariable Index Reference:\n";
   int GVCount = 0;
-  for (auto &GV : Program->globals())
+  for (auto &GV : Program.globals())
     if (GV.hasInitializer())
       outs() << "\t" << ++GVCount << ": " << GV.getName() << "\n";
   outs() << "----------------------------\n";
   return GVCount;
 }
 
 void llvm::reduceGlobalsInitializersDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing GVs initializers...\n";
   int GVCount = countGVs(Test.getProgram());
   runDeltaPass(Test, GVCount, extractGVsFromModule);
 }

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

 
 #include "ReduceGlobalVars.h"
 #include "llvm/IR/Constants.h"
 #include <set>
 
 using namespace llvm;
 
 /// Removes all the GVs that aren't inside the desired Chunks.
-static void extractGVsFromModule(std::vector<Chunk> ChunksToKeep,
-                                 Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractGVsFromModule(Oracle &O, Module &Program) {
   // Get GVs inside desired chunks
   std::set<GlobalVariable *> GVsToKeep;
-  for (auto &GV : Program->globals())
+  for (auto &GV : Program.globals())
     if (O.shouldKeep())
       GVsToKeep.insert(&GV);
 
   // Delete out-of-chunk GVs and their uses
   std::vector<GlobalVariable *> ToRemove;
   std::vector<WeakVH> InstToRemove;
-  for (auto &GV : Program->globals())
+  for (auto &GV : Program.globals())
     if (!GVsToKeep.count(&GV)) {
       for (auto *U : GV.users())
         if (auto *Inst = dyn_cast<Instruction>(U))
           InstToRemove.push_back(Inst);
 
       GV.replaceAllUsesWith(UndefValue::get(GV.getType()));
       ToRemove.push_back(&GV);
     }
 
   // Delete (unique) Instruction uses of unwanted GVs
   for (Value *V : InstToRemove) {
     if (!V)
       continue;
     auto *Inst = cast<Instruction>(V);
     Inst->replaceAllUsesWith(UndefValue::get(Inst->getType()));
     Inst->eraseFromParent();
   }
 
   for (auto *GV : ToRemove)
     GV->eraseFromParent();
 }
 
 /// Counts the amount of GVs and displays their
 /// respective name & index
-static int countGVs(Module *Program) {
+static int countGVs(Module &Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   outs() << "GlobalVariable Index Reference:\n";
   int GVCount = 0;
-  for (auto &GV : Program->globals())
+  for (auto &GV : Program.globals())
     outs() << "\t" << ++GVCount << ": " << GV.getName() << "\n";
   outs() << "----------------------------\n";
   return GVCount;
 }
 
 void llvm::reduceGlobalsDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing GVs...\n";
   int GVCount = countGVs(Test.getProgram());
   runDeltaPass(Test, GVCount, extractGVsFromModule);
 }

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

 //===----------------------------------------------------------------------===//
 
 #include "ReduceInstructions.h"
 
 using namespace llvm;
 
 /// Removes out-of-chunk arguments from functions, and modifies their calls
 /// accordingly. It also removes allocations of out-of-chunk arguments.
-static void extractInstrFromModule(std::vector<Chunk> ChunksToKeep,
-                                   Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractInstrFromModule(Oracle &O, Module &Program) {
   std::set<Instruction *> InstToKeep;
 
-  for (auto &F : *Program)
+  for (auto &F : Program)
     for (auto &BB : F) {
       // Removing the terminator would make the block invalid. Only iterate over
       // instructions before the terminator.
       InstToKeep.insert(BB.getTerminator());
       for (auto &Inst : make_range(BB.begin(), std::prev(BB.end())))
         if (O.shouldKeep())
           InstToKeep.insert(&Inst);
     }
 
   std::vector<Instruction *> InstToDelete;
-  for (auto &F : *Program)
+  for (auto &F : Program)
     for (auto &BB : F)
       for (auto &Inst : BB)
         if (!InstToKeep.count(&Inst)) {
           Inst.replaceAllUsesWith(UndefValue::get(Inst.getType()));
           InstToDelete.push_back(&Inst);
         }
 
   for (auto &I : InstToDelete)
     I->eraseFromParent();
 }
 
 /// Counts the amount of basic blocks and prints their name & respective index
-static unsigned countInstructions(Module *Program) {
+static unsigned countInstructions(Module &Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   int InstCount = 0;
-  for (auto &F : *Program)
+  for (auto &F : Program)
     for (auto &BB : F)
       // Well-formed blocks have terminators, which we cannot remove.
       InstCount += BB.getInstList().size() - 1;
   outs() << "Number of instructions: " << InstCount << "\n";
 
   return InstCount;
 }
 
 void llvm::reduceInstructionsDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Instructions...\n";
   unsigned InstCount = countInstructions(Test.getProgram());
   runDeltaPass(Test, InstCount, extractInstrFromModule);
 }

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

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/InstIterator.h"
 #include <vector>
 
 using namespace llvm;
 
 /// Removes all the Named and Unnamed Metadata Nodes, as well as any debug
 /// functions that aren't inside the desired Chunks.
-static void extractMetadataFromModule(const std::vector<Chunk> &ChunksToKeep,
-                                      Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractMetadataFromModule(Oracle &O, Module &Program) {
   // Get out-of-chunk Named metadata nodes
   SmallVector<NamedMDNode *> NamedNodesToDelete;
-  for (NamedMDNode &MD : Program->named_metadata())
+  for (NamedMDNode &MD : Program.named_metadata())
     if (!O.shouldKeep())
       NamedNodesToDelete.push_back(&MD);
 
   for (NamedMDNode *NN : NamedNodesToDelete) {
     for (auto I : seq<unsigned>(0, NN->getNumOperands()))
       NN->setOperand(I, NULL);
     NN->eraseFromParent();
   }
 
   // Delete out-of-chunk metadata attached to globals.
   SmallVector<std::pair<unsigned, MDNode *>> MDs;
-  for (GlobalVariable &GV : Program->globals()) {
+  for (GlobalVariable &GV : Program.globals()) {
     GV.getAllMetadata(MDs);
     for (std::pair<unsigned, MDNode *> &MD : MDs)
       if (!O.shouldKeep())
         GV.setMetadata(MD.first, NULL);
   }
 
-  for (Function &F : *Program) {
+  for (Function &F : Program) {
     // Delete out-of-chunk metadata attached to functions.
     F.getAllMetadata(MDs);
     for (std::pair<unsigned, MDNode *> &MD : MDs)
       if (!O.shouldKeep())
         F.setMetadata(MD.first, NULL);
 
     // Delete out-of-chunk metadata attached to instructions.
     for (Instruction &I : instructions(F)) {
       I.getAllMetadata(MDs);
       for (std::pair<unsigned, MDNode *> &MD : MDs)
         if (!O.shouldKeep())
           I.setMetadata(MD.first, NULL);
     }
   }
 }
 
-static int countMetadataTargets(Module *Program) {
-  int NamedMetadataNodes = Program->named_metadata_size();
+static int countMetadataTargets(Module &Program) {
+  int NamedMetadataNodes = Program.named_metadata_size();
 
   // Get metadata attached to globals.
   int GlobalMetadataArgs = 0;
   SmallVector<std::pair<unsigned, MDNode *>> MDs;
-  for (GlobalVariable &GV : Program->globals()) {
+  for (GlobalVariable &GV : Program.globals()) {
     GV.getAllMetadata(MDs);
     GlobalMetadataArgs += MDs.size();
   }
 
   // Get metadata attached to functions & instructions.
   int FunctionMetadataArgs = 0;
   int InstructionMetadataArgs = 0;
-  for (Function &F : *Program) {
+  for (Function &F : Program) {
     F.getAllMetadata(MDs);
     FunctionMetadataArgs += MDs.size();
 
     for (Instruction &I : instructions(F)) {
       I.getAllMetadata(MDs);
       InstructionMetadataArgs += MDs.size();
     }
   }

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

 //===- ReduceModuleData.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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a reduce pass to reduce various module data.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReduceModuleData.h"
 
 using namespace llvm;
 
-static void clearModuleData(std::vector<Chunk> ChunksToKeep, Module *Program) {
-  Oracle O(ChunksToKeep);
-
-  if (!Program->getModuleIdentifier().empty() && !O.shouldKeep())
-    Program->setModuleIdentifier("");
-  if (!Program->getSourceFileName().empty() && !O.shouldKeep())
-    Program->setSourceFileName("");
-  if (!Program->getDataLayoutStr().empty() && !O.shouldKeep())
-    Program->setDataLayout("");
-  if (!Program->getTargetTriple().empty() && !O.shouldKeep())
-    Program->setTargetTriple("");
+static void clearModuleData(Oracle &O, Module &Program) {
+  if (!Program.getModuleIdentifier().empty() && !O.shouldKeep())
+    Program.setModuleIdentifier("");
+  if (!Program.getSourceFileName().empty() && !O.shouldKeep())
+    Program.setSourceFileName("");
+  if (!Program.getDataLayoutStr().empty() && !O.shouldKeep())
+    Program.setDataLayout("");
+  if (!Program.getTargetTriple().empty() && !O.shouldKeep())
+    Program.setTargetTriple("");
   // TODO: clear line by line rather than all at once
-  if (!Program->getModuleInlineAsm().empty() && !O.shouldKeep())
-    Program->setModuleInlineAsm("");
+  if (!Program.getModuleInlineAsm().empty() && !O.shouldKeep())
+    Program.setModuleInlineAsm("");
 }
 
-static int countModuleData(Module *M) {
+static int countModuleData(Module &M) {
   int Count = 0;
-  if (!M->getModuleIdentifier().empty())
+  if (!M.getModuleIdentifier().empty())
     ++Count;
-  if (!M->getSourceFileName().empty())
+  if (!M.getSourceFileName().empty())
     ++Count;
-  if (!M->getDataLayoutStr().empty())
+  if (!M.getDataLayoutStr().empty())
     ++Count;
-  if (!M->getTargetTriple().empty())
+  if (!M.getTargetTriple().empty())
     ++Count;
-  if (!M->getModuleInlineAsm().empty())
+  if (!M.getModuleInlineAsm().empty())
     ++Count;
   return Count;
 }
 
 void llvm::reduceModuleDataDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Module Data...\n";
   int Count = countModuleData(Test.getProgram());
   runDeltaPass(Test, Count, clearModuleData);
 }

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

 
 using namespace llvm;
 
 namespace {
 
 /// Given ChunksToKeep, produce a map of calls and indexes of operand bundles
 /// to be preserved for each call.
 class OperandBundleRemapper : public InstVisitor<OperandBundleRemapper> {
-  Oracle O;
+  Oracle &O;
 
 public:
   DenseMap<CallBase *, std::vector<unsigned>> CallsToRefine;
 
-  explicit OperandBundleRemapper(ArrayRef<Chunk> ChunksToKeep)
-      : O(ChunksToKeep) {}
+  explicit OperandBundleRemapper(Oracle &O) : O(O) {}
 
   /// So far only CallBase sub-classes can have operand bundles.
   /// Let's see which of the operand bundles of this call are to be kept.
   void visitCallBase(CallBase &Call) {
     if (!Call.hasOperandBundles())
       return; // No bundles to begin with.
 
     // Insert this call into map, we will likely want to rebuild it.
static void maybeRewriteCallWithDifferentBundles(
 
   // Finally actually replace the bundles on the call.
   CallBase *NewCall = CallBase::Create(OrigCall, NewBundles, OrigCall);
   OrigCall->replaceAllUsesWith(NewCall);
   OrigCall->eraseFromParent();
 }
 
 /// Removes out-of-chunk operand bundles from calls.
-static void extractOperandBundesFromModule(std::vector<Chunk> ChunksToKeep,
-                                           Module *Program) {
-  OperandBundleRemapper R(ChunksToKeep);
+static void extractOperandBundesFromModule(Oracle &O, Module &Program) {
+  OperandBundleRemapper R(O);
   R.visit(Program);
 
   for (const auto &I : R.CallsToRefine)
     maybeRewriteCallWithDifferentBundles(I.first, I.second);
 }
 
 /// Counts the amount of operand bundles.
-static int countOperandBundes(Module *Program) {
+static int countOperandBundes(Module &Program) {
   OperandBundleCounter C;
 
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   C.visit(Program);
   outs() << "Number of operand bundles: " << C.OperandBundeCount << "\n";
 
   return C.OperandBundeCount;
 }
 
 void llvm::reduceOperandBundesDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing OperandBundes...\n";
   int OperandBundeCount = countOperandBundes(Test.getProgram());
   runDeltaPass(Test, OperandBundeCount, extractOperandBundesFromModule);
 }

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

 /// check what types that are not reducible.
 static bool canReduceOperand(Use &Op) {
   auto *Ty = Op->getType();
   // Can't reduce labels to undef
   return !Ty->isLabelTy() && !operandIsUndefValue(Op);
 }
 
 /// Sets Operands to undef.
-static void extractOperandsFromModule(std::vector<Chunk> ChunksToKeep,
-                                      Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractOperandsFromModule(Oracle &O, Module &Program) {
   // Extract Operands from the module.
-  for (auto &F : Program->functions()) {
+  for (auto &F : Program.functions()) {
     for (auto &I : instructions(&F)) {
       for (auto &Op : I.operands()) {
         // Filter Operands then set to undef.
         if (canReduceOperand(Op) && !O.shouldKeep()) {
           auto *Ty = Op->getType();
           Op.set(UndefValue::get(Ty));
         }
       }
     }
   }
 }
 
 /// Counts the amount of operands in the module that can be reduced.
-static int countOperands(Module *Program) {
+static int countOperands(Module &Program) {
   int Count = 0;
-  for (auto &F : Program->functions()) {
+  for (auto &F : Program.functions()) {
     for (auto &I : instructions(&F)) {
       for (auto &Op : I.operands()) {
         if (canReduceOperand(Op)) {
           Count++;
         }
       }
     }
   }
   return Count;
 }
 
 void llvm::reduceOperandsDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Operands...\n";
   int Count = countOperands(Test.getProgram());
   runDeltaPass(Test, Count, extractOperandsFromModule);
 }

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

 #include "llvm/IR/GlobalValue.h"
 
 using namespace llvm;
 
 static StringRef SpecialGlobalNames[] = {"llvm.used", "llvm.compiler.used"};
 
 /// Removes all special globals aren't inside any of the
 /// desired Chunks.
-static void
-extractSpecialGlobalsFromModule(const std::vector<Chunk> &ChunksToKeep,
-                                Module *Program) {
-  Oracle O(ChunksToKeep);
-
+static void extractSpecialGlobalsFromModule(Oracle &O, Module &Program) {
   for (StringRef Name : SpecialGlobalNames) {
-    if (auto *Used = Program->getNamedGlobal(Name)) {
+    if (auto *Used = Program.getNamedGlobal(Name)) {
       Used->replaceAllUsesWith(UndefValue::get(Used->getType()));
       Used->eraseFromParent();
     }
   }
 }
 
 /// Counts the amount of special globals and prints their
 /// respective name & index
-static int countSpecialGlobals(Module *Program) {
+static int countSpecialGlobals(Module &Program) {
   // TODO: Silence index with --quiet flag
   errs() << "----------------------------\n";
   errs() << "Special Globals Index Reference:\n";
   int Count = 0;
   for (StringRef Name : SpecialGlobalNames) {
-    if (auto *Used = Program->getNamedGlobal(Name))
+    if (auto *Used = Program.getNamedGlobal(Name))
       errs() << "\t" << ++Count << ": " << Used->getName() << "\n";
   }
   errs() << "----------------------------\n";
   return Count;
 }
 
 void llvm::reduceSpecialGlobalsDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Special Globals ...\n";
   int Functions = countSpecialGlobals(Test.getProgram());
   runDeltaPass(Test, Functions, extractSpecialGlobalsFromModule);
   errs() << "----------------------------\n";
 }

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

static std::unique_ptr<Module> parseInputFile(StringRef Filename,
   if (verifyModule(*Result, &errs())) {
     errs() << "Error: " << Filename << " - input module is broken!\n";
     return std::unique_ptr<Module>();
   }
 
   return Result;
 }
 
-void writeOutput(Module *M, StringRef Message) {
+void writeOutput(Module &M, StringRef Message) {
   if (ReplaceInput) // In-place
     OutputFilename = InputFilename.c_str();
   else if (OutputFilename.empty() || OutputFilename == "-")
     OutputFilename = "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);
+  M.print(Out, /*AnnotationWriter=*/nullptr);
   errs() << Message << OutputFilename << "\n";
 }
 
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
 
   cl::HideUnrelatedOptions({&Options, &getColorCategory()});
   cl::ParseCommandLineOptions(Argc, Argv, "LLVM automatic testcase reducer.\n");
 
   if (PrintDeltaPasses) {
     printDeltaPasses(errs());
     return 0;
   }
 
   LLVMContext Context;
   std::unique_ptr<Module> OriginalProgram =
       parseInputFile(InputFilename, Context);
 
   if (!OriginalProgram) {
     return 1;
   }
 
   // Initialize test environment
-  TestRunner Tester(TestFilename, TestArguments);
-  Tester.setProgram(std::move(OriginalProgram));
+  TestRunner Tester(TestFilename, TestArguments, std::move(OriginalProgram));
 
   // Try to reduce code
   runDeltaPasses(Tester);
 
-  if (!Tester.getProgram()) {
-    errs() << "\nCouldnt reduce input :/\n";
-  } else {
-    // Print reduced file to STDOUT
-    if (OutputFilename == "-")
-      Tester.getProgram()->print(outs(), nullptr);
-    else
-      writeOutput(Tester.getProgram(), "\nDone reducing! Reduced testcase: ");
-  }
+    Tester.getProgram().print(outs(), nullptr);
 
   return 0;
 }