this change allows the user to specify the largest number of times that llvm-reduce's main delta loop will run. however, llvm-reduce will exit earlier than this if non-progress is detected; this happens when running the full set of delta passes...

[regehr]

Summary

...fails to decrease the size of the IR file that is currently being reduced

llvm/tools/llvm-reduce/DeltaManager.h

 #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAMANAGER_H
 #define LLVM_TOOLS_LLVM_REDUCE_DELTAMANAGER_H
 
 namespace llvm {
 class raw_ostream;
 class TestRunner;
 
 void printDeltaPasses(raw_ostream &OS);
-void runDeltaPasses(TestRunner &Tester);
+void runDeltaPasses(TestRunner &Tester, int MaxPassIterations);
 } // namespace llvm
 
 #endif

llvm/tools/llvm-reduce/DeltaManager.cpp

 #define DELTA_PASS(NAME, FUNC) OS << "  " << NAME << "\n";
   OS << " IR:\n";
   DELTA_PASSES
   OS << " MIR:\n";
   DELTA_PASSES_MIR
 #undef DELTA_PASS
 }
 
-void llvm::runDeltaPasses(TestRunner &Tester) {
+// FIXME: We might want to use a different metric than "number of
+// bytes in serialized IR" to detect non-progress of the main delta
+// loop
+static int getIRSize(TestRunner &Tester) {
+  std::string Str;
+  raw_string_ostream SS(Str);
+  Tester.getProgram().print(SS, /*AnnotationWriter=*/nullptr);
+  return Str.length();
+}
+
+void llvm::runDeltaPasses(TestRunner &Tester, int MaxPassIterations) {
+  int OldSize = getIRSize(Tester);
+  for (int Iter = 0; Iter < MaxPassIterations; ++Iter) {
     if (DeltaPasses.empty()) {
       runAllDeltaPasses(Tester);
     } else {
       StringRef Passes = DeltaPasses;
       while (!Passes.empty()) {
         auto Split = Passes.split(",");
         runDeltaPassName(Tester, Split.first);
         Passes = Split.second;
       }
     }
+    int NewSize = getIRSize(Tester);
+    if (NewSize >= OldSize)
+      break;
+    OldSize = NewSize;
+  }
 }

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

InputLanguage("x", cl::ValueOptional,
                   cl::values(clEnumValN(InputLanguages::IR, "ir", ""),
                              clEnumValN(InputLanguages::MIR, "mir", "")),
                   cl::cat(Options));
 
 static cl::opt<std::string> TargetTriple("mtriple",
                                          cl::desc("Set the target triple"),
                                          cl::cat(Options));
 
+static cl::opt<int>
+    MaxPassIterations("max-pass-iterations",
+                      cl::desc("Maximum number of times to run the full set "
+                               "of delta passes (default=1)"),
+                      cl::init(1), cl::cat(Options));
+
 static codegen::RegisterCodeGenFlags CGF;
 
 void writeOutput(ReducerWorkItem &M, StringRef Message) {
   if (ReplaceInput) // In-place
     OutputFilename = InputFilename.c_str();
   else if (OutputFilename.empty() || OutputFilename == "-")
     OutputFilename = M.isMIR() ? "reduced.mir" : "reduced.ll";
   std::error_code EC;
int main(int Argc, char **Argv) {
   if (!OriginalProgram) {
     return 1;
   }
 
   // Initialize test environment
   TestRunner Tester(TestFilename, TestArguments, std::move(OriginalProgram));
 
   // Try to reduce code
-  runDeltaPasses(Tester);
+  runDeltaPasses(Tester, MaxPassIterations);
 
   // Print reduced file to STDOUT
   if (OutputFilename == "-")
     Tester.getProgram().print(outs(), nullptr);
   else
     writeOutput(Tester.getProgram(), "\nDone reducing! Reduced testcase: ");
 
   return 0;
 }