llvm-reduce: Improve delta pass flag handling

[arsenm]

Summary

Verify all the requested passes exist before trying to run any.
For long reductions, it was really annoying for it to get halfway through
and then I come back later to an incomplete reduction.

Also add a new skip-delta-passes flag. Most of the time I want to opt out
of specific reductions, rather than run a select few.

[regehr]

LGTM

llvm/tools/llvm-reduce/DeltaManager.cpp

202

unintended whitespace change?

[aeubanks]

llvm/tools/llvm-reduce/DeltaManager.cpp

133–134

now unreachable?

150

there's already a StringRef::split overload that does this

there's also cl::CommaSeparated as part of cl::opt

185–186

with cl::CommaSeparated it should be easier to just create a set for skipped and just a list for RunPassList.

[arsenm]

Let cl::opt handle the lists and use unreachable

[arsenm]

c3bc72ccb23eb13aa6efba81adf68a0518eebc52

llvm/test/tools/llvm-reduce/skip-delta-passes.ll

+; RUN: llvm-reduce --delta-passes=attributes --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: FileCheck -check-prefix=RESULT %s < %t
+
+; RUN: llvm-reduce --delta-passes=instructions,attributes --skip-delta-passes=instructions --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: FileCheck -check-prefix=RESULT %s < %t
+
+; RUN: not llvm-reduce --skip-delta-passes=foo --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t 2>&1 | FileCheck %s --check-prefix=ERROR
+
+
+; CHECK-INTERESTINGNESS: @foo
+; RESULT: define void @foo() {
+; RESULT-NEXT: store i32
+; RESULT-NEXT: ret void
+; RESULT0-NOT: attributes
+
+; ERROR: unknown pass "foo"
+define void @foo() #0 {
+  store i32 0, ptr null
+  ret void
+}
+
+attributes #0 = { "arstarstarst" }

llvm/tools/llvm-reduce/DeltaManager.cpp

 #include "deltas/ReduceUsingSimplifyCFG.h"
 #include "deltas/ReduceVirtualRegisters.h"
 #include "deltas/RunIRPasses.h"
 #include "deltas/SimplifyInstructions.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
+using SmallStringSet = SmallSet<StringRef, 8>;
+
 extern cl::OptionCategory LLVMReduceOptions;
-static cl::opt<std::string>
+static cl::list<std::string>
     DeltaPasses("delta-passes",
                 cl::desc("Delta passes to run, separated by commas. By "
                          "default, run all delta passes."),
-                cl::cat(LLVMReduceOptions));
+                cl::cat(LLVMReduceOptions), cl::CommaSeparated);
+
+static cl::list<std::string>
+    SkipDeltaPasses("skip-delta-passes",
+                    cl::desc("Delta passes to not run, separated by commas. By "
+                             "default, run all delta passes."),
+                    cl::cat(LLVMReduceOptions), cl::CommaSeparated);
 
 #define DELTA_PASSES                                                           \
   do {                                                                         \
     DELTA_PASS("functions", reduceFunctionsDeltaPass)                          \
     DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass)               \
     DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass)               \
     DELTA_PASS("aliases", reduceAliasesDeltaPass)                              \
     DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass)                     \
do {                                                                         \
     DELTA_PASS("ir-function-references", reduceIRFunctionReferencesDeltaPass)  \
     DELTA_PASS("instruction-flags", reduceInstructionFlagsMIRDeltaPass)        \
     DELTA_PASS("register-uses", reduceRegisterUsesMIRDeltaPass)                \
     DELTA_PASS("register-defs", reduceRegisterDefsMIRDeltaPass)                \
     DELTA_PASS("register-hints", reduceVirtualRegisterHintsDeltaPass)          \
     DELTA_PASS("register-masks", reduceRegisterMasksMIRDeltaPass)              \
   } while (false)
 
-static void runAllDeltaPasses(TestRunner &Tester) {
-#define DELTA_PASS(NAME, FUNC) FUNC(Tester);
+static void runAllDeltaPasses(TestRunner &Tester,
+                              const SmallStringSet &SkipPass) {
+#define DELTA_PASS(NAME, FUNC)                                                 \
+  if (!SkipPass.count(NAME)) {                                                 \
+    FUNC(Tester);                                                              \
+  }
   if (Tester.getProgram().isMIR()) {
     DELTA_PASSES_MIR;
   } else {
     DELTA_PASSES;
   }
 #undef DELTA_PASS
 }
 
 static void runDeltaPassName(TestRunner &Tester, StringRef PassName) {
 #define DELTA_PASS(NAME, FUNC)                                                 \
   if (PassName == NAME) {                                                      \
     FUNC(Tester);                                                              \
     return;                                                                    \
   }
   if (Tester.getProgram().isMIR()) {
     DELTA_PASSES_MIR;
   } else {
     DELTA_PASSES;
   }
 #undef DELTA_PASS
-  errs() << "unknown pass \"" << PassName << "\"\n";
-  exit(1);
+
+  // We should have errored on unrecognized passes before trying to run
+  // anything.
+  llvm_unreachable("unknown delta pass");
 }
 
 void llvm::printDeltaPasses(raw_ostream &OS) {
   OS << "Delta passes (pass to `--delta-passes=` as a comma separated list):\n";
 #define DELTA_PASS(NAME, FUNC) OS << "  " << NAME << "\n";
   OS << " IR:\n";
   DELTA_PASSES;
   OS << " MIR:\n";
   DELTA_PASSES_MIR;
 #undef DELTA_PASS
 }
 
+// Built a set of available delta passes.
+static void collectPassNames(const TestRunner &Tester,
+                             SmallStringSet &NameSet) {
+#define DELTA_PASS(NAME, FUNC) NameSet.insert(NAME);
+  if (Tester.getProgram().isMIR()) {
+    DELTA_PASSES_MIR;
+  } else {
+    DELTA_PASSES;
+  }
+#undef DELTA_PASS
+}
+
+/// Verify all requested or skipped passes are valid names, and return them in a
+/// set.
+static SmallStringSet handlePassList(const TestRunner &Tester,
+                                     const cl::list<std::string> &PassList) {
+  SmallStringSet AllPasses;
+  collectPassNames(Tester, AllPasses);
+
+  SmallStringSet PassSet;
+  for (StringRef PassName : PassList) {
+    if (!AllPasses.count(PassName)) {
+      errs() << "unknown pass \"" << PassName << "\"\n";
+      exit(1);
+    }
+
+    PassSet.insert(PassName);
+  }
+
+  return PassSet;
+}
+
 void llvm::runDeltaPasses(TestRunner &Tester, int MaxPassIterations) {
   uint64_t OldComplexity = Tester.getProgram().getComplexityScore();
+
+  SmallStringSet RunPassSet, SkipPassSet;
+
+  if (!DeltaPasses.empty())
+    RunPassSet = handlePassList(Tester, DeltaPasses);
+
+  if (!SkipDeltaPasses.empty())
+    SkipPassSet = handlePassList(Tester, SkipDeltaPasses);
+
   for (int Iter = 0; Iter < MaxPassIterations; ++Iter) {
     if (DeltaPasses.empty()) {
-      runAllDeltaPasses(Tester);
+      runAllDeltaPasses(Tester, SkipPassSet);
     } else {
-      StringRef Passes = DeltaPasses;
-      while (!Passes.empty()) {
-        auto Split = Passes.split(",");
-        runDeltaPassName(Tester, Split.first);
-        Passes = Split.second;
+      for (StringRef PassName : DeltaPasses) {
+        if (!SkipPassSet.count(PassName))
+          runDeltaPassName(Tester, PassName);
       }
     }
+
     uint64_t NewComplexity = Tester.getProgram().getComplexityScore();
     if (NewComplexity >= OldComplexity)
       break;
     OldComplexity = NewComplexity;
   }
 }