[llvm-reduce] Add flag to only run specific passes

[swamulism]

llvm/tools/llvm-reduce/DeltaManager.cpp

94–121

Is it possible to add documentation for this either in a --help menu or elsewhere?

[aeubanks]

add flag to print passes

[aeubanks]

remove unrelated change

[hans]

lgtm

+1 to the comment that it would be nice to have some docs; llvm-reduce should have a page on https://llvm.org/docs/CommandGuide/ really

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

18

is it used in this file?

[fhahn]

Can you add a test for the new option?

[aeubanks]

unintentional include

[aeubanks]

In D101278#2729915, @fhahn wrote:

Can you add a test for the new option?

which option? custom-delta-passes.ll should be testing all of them

[fhahn]

In D101278#2729936, @aeubanks wrote:

In D101278#2729915, @fhahn wrote:

Can you add a test for the new option?

which option? custom-delta-passes.ll should be testing all of them

arg sorry I missed that print-delta-passes is also part of llvm/test/tools/llvm-reduce/custom-delta-passes.ll

LGTM

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

+; RUN: llvm-reduce --delta-passes=module-inline-asm --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: FileCheck --check-prefix=CHECK-NOCHANGE %s < %t
+; RUN: llvm-reduce --delta-passes=function-bodies --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: FileCheck --check-prefix=CHECK-CHANGE %s < %t
+; RUN: llvm-reduce --delta-passes=function-bodies,module-inline-asm --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: FileCheck --check-prefix=CHECK-CHANGE %s < %t
+
+; RUN: not llvm-reduce --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
+; RUN: not llvm-reduce --delta-passes='function-bodies;module-inline-asm' --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
+
+; RUN: llvm-reduce --print-delta-passes --test FileCheck %s 2>&1 | FileCheck %s --check-prefix=PRINT
+
+; CHECK-INTERESTINGNESS: @f
+
+; CHECK-NOCHANGE: define {{.*}} @f
+; CHECK-CHANGE: declare {{.*}} @f
+
+; ERROR: unknown
+
+; PRINT: function-bodies
+
+define void @f() {
+  ret void
+}

llvm/tools/llvm-reduce/DeltaManager.h

 //===- DeltaManager.h - Runs Delta Passes to reduce Input -----------------===//
 //
 // 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 calls each specialized Delta pass in order to reduce the input IR
 // file.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAMANAGER_H
 #define LLVM_TOOLS_LLVM_REDUCE_DELTAMANAGER_H
 
-#include "TestRunner.h"
-
 namespace llvm {
+class raw_ostream;
+class TestRunner;
+
+void printDeltaPasses(raw_ostream &OS);
 void runDeltaPasses(TestRunner &Tester);
 } // namespace llvm
 
 #endif

llvm/tools/llvm-reduce/DeltaManager.cpp

 #include "deltas/ReduceGlobalValues.h"
 #include "deltas/ReduceGlobalVarInitializers.h"
 #include "deltas/ReduceGlobalVars.h"
 #include "deltas/ReduceInstructions.h"
 #include "deltas/ReduceMetadata.h"
 #include "deltas/ReduceModuleInlineAsm.h"
 #include "deltas/ReduceOperandBundles.h"
 #include "deltas/ReduceSpecialGlobals.h"
+#include "llvm/Support/CommandLine.h"
 
-namespace llvm {
+using namespace llvm;
 
-// TODO: Add CLI option to run only specified Passes (for unit tests)
-void runDeltaPasses(TestRunner &Tester) {
-  reduceSpecialGlobalsDeltaPass(Tester);
-  reduceAliasesDeltaPass(Tester);
-  reduceFunctionBodiesDeltaPass(Tester);
-  reduceFunctionsDeltaPass(Tester);
-  reduceBasicBlocksDeltaPass(Tester);
-  reduceGlobalValuesDeltaPass(Tester);
-  reduceGlobalsInitializersDeltaPass(Tester);
-  reduceGlobalsDeltaPass(Tester);
-  reduceMetadataDeltaPass(Tester);
-  reduceArgumentsDeltaPass(Tester);
-  reduceInstructionsDeltaPass(Tester);
-  reduceOperandBundesDeltaPass(Tester);
-  reduceAttributesDeltaPass(Tester);
-  reduceModuleInlineAsmDeltaPass(Tester);
-  // TODO: Implement the remaining Delta Passes
+static cl::opt<std::string>
+    DeltaPasses("delta-passes",
+                cl::desc("Delta passes to run, separated by commas. By "
+                         "default, run all delta passes."));
+
+#define DELTA_PASSES                                                           \
+  DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass)                 \
+  DELTA_PASS("aliases", reduceAliasesDeltaPass)                                \
+  DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass)                 \
+  DELTA_PASS("functions", reduceFunctionsDeltaPass)                            \
+  DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass)                       \
+  DELTA_PASS("global-values", reduceGlobalValuesDeltaPass)                     \
+  DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass)        \
+  DELTA_PASS("global-variables", reduceGlobalsDeltaPass)                       \
+  DELTA_PASS("metadata", reduceMetadataDeltaPass)                              \
+  DELTA_PASS("arguments", reduceArgumentsDeltaPass)                            \
+  DELTA_PASS("instructions", reduceInstructionsDeltaPass)                      \
+  DELTA_PASS("operand-bundles", reduceOperandBundesDeltaPass)                  \
+  DELTA_PASS("attributes", reduceAttributesDeltaPass)                          \
+  DELTA_PASS("module-inline-asm", reduceModuleInlineAsmDeltaPass)
+
+static void runAllDeltaPasses(TestRunner &Tester) {
+#define DELTA_PASS(NAME, FUNC) FUNC(Tester);
+  DELTA_PASSES
+#undef DELTA_PASS
+}
+
+static void runDeltaPassName(TestRunner &Tester, StringRef PassName) {
+#define DELTA_PASS(NAME, FUNC)                                                 \
+  if (PassName == NAME) {                                                      \
+    FUNC(Tester);                                                              \
+    return;                                                                    \
+  }
+  DELTA_PASSES
+#undef DELTA_PASS
+  errs() << "unknown pass \"" << PassName << "\"";
+  exit(1);
+}
+
+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";
+  DELTA_PASSES
+#undef DELTA_PASS
+}
+
+void llvm::runDeltaPasses(TestRunner &Tester) {
+  if (DeltaPasses.empty()) {
+    runAllDeltaPasses(Tester);
+  } else {
+    StringRef Passes = DeltaPasses;
+    while (!Passes.empty()) {
+      auto Split = Passes.split(",");
+      runDeltaPassName(Tester, Split.first);
+      Passes = Split.second;
+    }
+  }
 }
-} // namespace llvm

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

 // 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 "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include <fstream>
 #include <set>
 
 using namespace llvm;
 
 void writeOutput(llvm::Module *M, llvm::StringRef Message);

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

 // test. It runs multiple delta debugging passes in order to minimize the input
 // file. It's worth noting that this is a part of the bugpoint redesign
 // proposal, and thus a *temporary* tool that will eventually be integrated
 // into the bugpoint tool itself.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DeltaManager.h"
+#include "TestRunner.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 
 static cl::OptionCategory Options("llvm-reduce options");
 
 static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden,
                           cl::cat(Options));
 static cl::opt<bool> Version("v", cl::desc("Alias for -version"), cl::Hidden,
                              cl::cat(Options));
 
+static cl::opt<bool>
+    PrintDeltaPasses("print-delta-passes",
+                     cl::desc("Print list of delta passes, passable to "
+                              "--delta-passes as a comma separated list"));
+
 static cl::opt<std::string> InputFilename(cl::Positional, cl::Required,
                                           cl::desc("<input llvm ll/bc file>"),
                                           cl::cat(Options));
 
 static cl::opt<std::string>
     TestFilename("test", cl::Required,
                  cl::desc("Name of the interesting-ness test to be run"),
                  cl::cat(Options));
void writeOutput(Module *M, StringRef Message) {
   errs() << Message << OutputFilename << "\n";
 }
 
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
 
   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);
 
   // Initialize test environment
   TestRunner Tester(TestFilename, TestArguments);
   Tester.setProgram(std::move(OriginalProgram));