[OptBisect] Add flag to print IR when opt-bisect kicks in

[aeubanks]

Summary

-opt-bisect-print-ir-path=foo will dump the IR to foo when opt-bisect-limit starts skipping passes.

Currently we don't print the IR if the opt-bisect-limit is higher than the total number of times opt-bisect is called.

This makes getting the IR right before a bad transform easier.

[hans]

lgtm

Should this be documented somewhere?

[aeubanks]

add flag to documentation

llvm/docs/OptBisect.rst

::
   # When using Gold
   clang -flto -Wl,-plugin-opt,-opt-bisect-limit=256 my_file.o my_other_file.o
 
 LTO passes are run by a library instance invoked by the linker. Therefore any
 passes run in the primary driver compilation phase are not affected by options
 passed via '-Wl,-plugin-opt' and LTO passes are not affected by options
 passed to the driver-invoked LLVM invocation via '-mllvm'.
 
+Passing ``-opt-bisect-print-ir-path=path/foo.ll`` will dump the IR to
+``path/foo.ll`` when -opt-bisect-limit starts skipping passes.
 
 Bisection Index Values
 ======================
 
 The granularity of the optimizations associated with a single index value is
 variable.  Depending on how the optimization pass has been instrumented the
 value may be associated with as much as all transformations that would have
 been performed by an optimization pass on an IR unit for which it is invoked

llvm/include/llvm/Passes/StandardInstrumentations.h

public:
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 private:
   bool DebugLogging;
   bool shouldRun(StringRef PassID, Any IR);
 };
 
 class OptBisectInstrumentation {
+  bool HasWrittenIR = false;
+
 public:
   OptBisectInstrumentation() = default;
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 };
 
 struct PrintPassOptions {
   /// Print adaptors and pass managers.
   bool Verbose = false;

llvm/lib/Passes/StandardInstrumentations.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassInstrumentation.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/PrintPasses.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include <unordered_map>
static cl::opt<std::string> DotCfgDir(
     cl::Hidden, cl::init("./"));
 
 // An option to print the IR that was being processed when a pass crashes.
 static cl::opt<bool>
     PrintCrashIR("print-on-crash",
                  cl::desc("Print the last form of the IR before crash"),
                  cl::init(false), cl::Hidden);
 
+static cl::opt<std::string> OptBisectPrintIRPath(
+    "opt-bisect-print-ir-path",
+    cl::desc("Print IR to path when opt-bisect-limit is reached"), cl::Hidden);
+
 namespace {
 
 /// Extract Module out of \p IR unit. May return nullptr if \p IR does not match
 /// certain global filters. Will never return nullptr if \p Force is true.
 const Module *unwrapModule(Any IR, bool Force = false) {
   if (any_isa<const Module *>(IR))
     return any_cast<const Module *>(IR);
 
bool OptNoneInstrumentation::shouldRun(StringRef PassID, Any IR) {
   }
   return ShouldRun;
 }
 
 void OptBisectInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   if (!getOptBisector().isEnabled())
     return;
-  PIC.registerShouldRunOptionalPassCallback([](StringRef PassID, Any IR) {
-    return isIgnored(PassID) ||
-           getOptBisector().checkPass(PassID, getIRName(IR));
+  PIC.registerShouldRunOptionalPassCallback([this](StringRef PassID, Any IR) {
+    if (isIgnored(PassID))
+      return true;
+    bool ShouldRun = getOptBisector().checkPass(PassID, getIRName(IR));
+    if (!ShouldRun && !this->HasWrittenIR && !OptBisectPrintIRPath.empty()) {
+      // FIXME: print IR if limit is higher than number of opt-bisect
+      // invocations
+      this->HasWrittenIR = true;
+      const Module *M = unwrapModule(IR, /*Force=*/true);
+      assert(M && "expected Module");
+      std::error_code EC;
+      raw_fd_ostream OS(OptBisectPrintIRPath, EC);
+      if (EC)
+        report_fatal_error(errorCodeToError(EC));
+      M->print(OS, nullptr);
+    }
+    return ShouldRun;
   });
 }
 
 raw_ostream &PrintPassInstrumentation::print() {
   if (Opts.Indent) {
     assert(Indent >= 0);
     dbgs().indent(Indent);
   }

llvm/test/Other/opt-bisect-print-ir-path.ll

+; RUN: opt -disable-verify -passes=instcombine < %s -opt-bisect-limit=0 -opt-bisect-print-ir-path=%t -disable-output 
+; RUN: FileCheck %s --check-prefix=LIMIT0 --input-file %t
+; RUN: opt -disable-verify -passes=instcombine < %s -opt-bisect-limit=1 -opt-bisect-print-ir-path=%t -disable-output 
+; RUN: FileCheck %s --check-prefix=LIMIT1 --input-file %t
+; RUN: opt -disable-verify -passes=instcombine < %s -opt-bisect-limit=2 -opt-bisect-print-ir-path=%t -disable-output 
+; FIXME: print IR if limit is higher than number of opt-bisect invocations
+
+; Check that we only print the module once
+; RUN: opt -disable-verify -passes=instcombine < %s -opt-bisect-limit=1 -opt-bisect-print-ir-path=- -disable-output 2>&1 | FileCheck %s
+
+; LIMIT0: ret i32 %r
+; LIMIT0: ret i32 %r
+
+; LIMIT1: ret i32 2
+; LIMIT1: ret i32 %r
+
+; CHECK: ModuleID
+; CHECK-NOT: ModuleID
+
+define i32 @f1() {
+  %r = add i32 1, 1
+  ret i32 %r
+}
+
+define i32 @f2() {
+  %r = add i32 1, 1
+  ret i32 %r
+}