[Utils] Added the ability to print the pass number and IR after it is triggered

[dbakunevich]

Summary

As part of this patch, 2 options have been added:
print-pass-numbers and print-after-pass-number.

1) The print-pass-numbers option allows to print the pass names and their ordinals.
   The output of the option looks like this:
                Running pass ORDINAL PASS_NAME

2) The print-after-pass-number option allows to print IR after pass with the number
   which reported by print-passes-names.

[aeubanks]

just curious, what's the use case for this?

llvm/lib/Passes/StandardInstrumentations.cpp

739

seems like this should be part of PrintPassInstrumentation instead

742

this duplicates the logic below and always prints the entire module, can you keep it more consistent with the current code?

llvm/test/Other/print-after-pass-number.ll

1 ↗

(On Diff #517545)

this shouldn't use update_test_checks.py, it should be checking the headers the instrumentation prints

llvm/test/Other/print-pass-number.ll

3 ↗

(On Diff #517545)

I don't think this requires asserts

[apilipenko]

We would like to have a way to take a snapshot of the IR at a specific point in the pipeline. Currently, you can either print the IR before/after a given pass (-print-before=<passname>) or print before/after all (-print-before-all). print-before will print the IR before all occurrences of the given pass. print-before-all will, well, print before all passes. While print-before-all can be used to achieve the same functionality of printing the pipeline and looking at the IR at a specific point in the pipeline, it's not very practical. For large compilations, print-before-all might take minutes to produce gigabytes of output.

More specifically, we are building a UI tool to inspect the optimization pipeline and would like to use the new command line options for this automation.

[dbakunevich]

llvm/lib/Passes/StandardInstrumentations.cpp

739

I don't agree with you. All the logic described for saving the pass number and subsequent printing of the IR is tied to the logic of registering callbacks in the PrintIRInstrumentation class.

742

Okay, I'll change this moment.

llvm/test/Other/print-after-pass-number.ll

1 ↗

(On Diff #517545)

Okay, I'll change this moment.

llvm/test/Other/print-pass-number.ll

3 ↗

(On Diff #517545)

Okay, I'll change this moment.

[aeubanks]

llvm/lib/Passes/StandardInstrumentations.cpp

109

so that we don't have an explosion of flag combinations, can we make it so this flag only takes effect when the other -print flags are on? i.e. this doesn't turn on printing on its own, rather it controls what gets printed if we are printing. this does require also passing whatever other flag (e.g. -print-after-all but I think that's fine. this should simplify a lot of the conditionals

114

this seems more like print-at-pass-number rather than print-after-pass-number IIUC

736

might as well do this unconditionally

769–784

put this in an else

809

isn't 0 a valid value? maybe make -1 the sentinel value

[dbakunevich]

llvm/lib/Passes/StandardInstrumentations.cpp

809

PrintPassNumbers is a bool variable that is either true or false. Perhaps you meant PrintAfterPassNumber. If so, then inside this tool it was customary to count passes starting from 1. This is more convenient from the point of view of human perception. Therefore, the value 0 is not valid.

[dbakunevich]

llvm/lib/Passes/StandardInstrumentations.cpp

109

I don't agree with you. As part of a particular task, it may be necessary to display only a list of passes with them ordinals without IR.

[dbakunevich]

ping!

[aeubanks]

mostly looks good

I do think this number of conditions in PrintIRInstrumentation is getting to be a bit much, but for now this is fine

if we're sometimes not actually printing IR in PrintIRInstrumentation with print-pass-numbers and only printing Running pass..., I think we should consider merging it with PrintPassInstrumentation, but that doesn't need to be done here

llvm/lib/Passes/StandardInstrumentations.cpp

114

other function/var names/comments should be updated as well

772

extra space?

llvm/test/Other/print-after-pass-number.ll

5 ↗

(On Diff #521261)

we shouldn't check the exact IR here, something like

; AFTER: IR Dump after FooPass-3 on bar
; AFTER-NEXT: define i32 @bar

is better. and also a similar test for one where the IR is invalidated

[aeubanks]

llvm/lib/Passes/StandardInstrumentations.cpp

772

ditto for the one in printAfterPass, but actually shouldn't this go in printBeforePass?

llvm/test/Other/print-at-pass-number.ll

9–10

again, we shouldn't be checking the exact IR, that's prone to changes in the passes

and there should be a test for invalidated IR

[dbakunevich]

llvm/lib/Passes/StandardInstrumentations.cpp

772

No, this logic should be near with PrintAtPassNumber.

[dbakunevich]

ping!

[aeubanks]

lg with the one comment addressed

llvm/lib/Passes/StandardInstrumentations.cpp

772

I definitely think

++CurrentPassNumber;

if (shouldPrintPassNumbers())
  dbgs() << "Running pass " << CurrentPassNumber << " " << PassID << "\n";

should be in printBeforePass, there's no reason to duplicate it between the two printAfterPasses (e.g. the extra space wasn't updated in the copy above)

[dbakunevich]

llvm/lib/Passes/StandardInstrumentations.cpp

772

We can't do that because the before and after passes are different. Accordingly, if we transfer the printing of a pass with its ordinals to printBeforePass(), then the pass numbers will not correspond to those that can be displayed in printAfterPasses().

[dbakunevich]

ping!

[aeubanks]

llvm/lib/Passes/StandardInstrumentations.cpp

772

within a pass run, ++CurrentPassNumber happens before any usage of it right now, that won't change by moving it to printBeforePass

llvm/test/Other/print-at-pass-number.ll

9–10

ping on the invalidated IR test

[dbakunevich]

Updated

[aeubanks]

lgtm

llvm/include/llvm/Passes/StandardInstrumentations.h

 
 private:
   void printBeforePass(StringRef PassID, Any IR);
   void printAfterPass(StringRef PassID, Any IR);
   void printAfterPassInvalidated(StringRef PassID);
 
   bool shouldPrintBeforePass(StringRef PassID);
   bool shouldPrintAfterPass(StringRef PassID);
+  bool shouldPrintPassNumbers();
+  bool shouldPrintAtPassNumber();
 
   using PrintModuleDesc = std::tuple<const Module *, std::string, StringRef>;
 
   void pushModuleDesc(StringRef PassID, Any IR);
   PrintModuleDesc popModuleDesc(StringRef PassID);
 
   PassInstrumentationCallbacks *PIC;
   /// Stack of Module description, enough to print the module after a given
   /// pass.
   SmallVector<PrintModuleDesc, 2> ModuleDescStack;
+
+  /// Used for print-at-pass-number
+  unsigned CurrentPassNumber = 0;
 };
 
 class OptNoneInstrumentation {
 public:
   OptNoneInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 private:

llvm/lib/Passes/StandardInstrumentations.cpp

static cl::opt<bool>
     PrintCrashIR("print-on-crash",
                  cl::desc("Print the last form of the IR before crash"),
                  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);
 
+static cl::opt<bool> PrintPassNumbers(
+    "print-pass-numbers", cl::init(false), cl::Hidden,
+    cl::desc("Print pass names and their ordinals"));
+
+static cl::opt<unsigned>
+    PrintAtPassNumber("print-at-pass-number", cl::init(0), cl::Hidden,
+                cl::desc("Print IR at pass with this number as "
+                         "reported by print-passes-names"));
+
 namespace {
 
 // An option for specifying an executable that will be called with the IR
 // everytime it changes in the opt pipeline.  It will also be called on
 // the initial IR as it enters the pipeline.  The executable will be passed
 // the name of a temporary file containing the IR and the PassID.  This may
 // be used, for example, to call llc on the IR and run a test to determine
 // which pass makes a change that changes the functioning of the IR.

 void PrintIRInstrumentation::printBeforePass(StringRef PassID, Any IR) {
   if (isIgnored(PassID))
     return;
 
   // Saving Module for AfterPassInvalidated operations.
   // Note: here we rely on a fact that we do not change modules while
   // traversing the pipeline, so the latest captured module is good
   // for all print operations that has not happen yet.
-  if (shouldPrintAfterPass(PassID))
+  if (shouldPrintPassNumbers() || shouldPrintAtPassNumber() ||
+      shouldPrintAfterPass(PassID))
     pushModuleDesc(PassID, IR);
 
   if (!shouldPrintBeforePass(PassID))
     return;
 
   if (!shouldPrintIR(IR))
     return;
 
   dbgs() << "*** IR Dump Before " << PassID << " on " << getIRName(IR)
          << " ***\n";
   unwrapAndPrint(dbgs(), IR);
 }
 
 void PrintIRInstrumentation::printAfterPass(StringRef PassID, Any IR) {
   if (isIgnored(PassID))
     return;
 
-  if (!shouldPrintAfterPass(PassID))
+  if (!shouldPrintAfterPass(PassID) && !shouldPrintPassNumbers() &&
+      !shouldPrintAtPassNumber())
     return;
 
   const Module *M;
   std::string IRName;
   StringRef StoredPassID;
   std::tie(M, IRName, StoredPassID) = popModuleDesc(PassID);
   assert(StoredPassID == PassID && "mismatched PassID");
 
   if (!shouldPrintIR(IR))
     return;
 
-  dbgs() << "*** IR Dump After " << PassID << " on " << IRName << " ***\n";
+  ++CurrentPassNumber;
+
+  if (shouldPrintPassNumbers())
+    dbgs() << " Running pass " << CurrentPassNumber << " " << PassID << "\n";
+
+  if (!shouldPrintAfterPass(PassID))
+    return;
+
+  dbgs() << "*** IR Dump "
+         << (shouldPrintAtPassNumber()
+                 ? StringRef(formatv("At {0}-{1}", CurrentPassNumber, PassID))
+                 : StringRef(formatv("After {0}", PassID)))
+         << " on " << IRName << " ***\n";
   unwrapAndPrint(dbgs(), IR);
 }
 
 void PrintIRInstrumentation::printAfterPassInvalidated(StringRef PassID) {
-  if (!shouldPrintAfterPass(PassID))
+  if (isIgnored(PassID))
     return;
 
-  if (isIgnored(PassID))
+  if (!shouldPrintAfterPass(PassID) && !shouldPrintPassNumbers() &&
+      !shouldPrintAtPassNumber())
     return;
 
   const Module *M;
   std::string IRName;
   StringRef StoredPassID;
   std::tie(M, IRName, StoredPassID) = popModuleDesc(PassID);
   assert(StoredPassID == PassID && "mismatched PassID");
   // Additional filtering (e.g. -filter-print-func) can lead to module
   // printing being skipped.
   if (!M)
     return;
 
-  SmallString<20> Banner =
-      formatv("*** IR Dump After {0} on {1} (invalidated) ***", PassID, IRName);
+  ++CurrentPassNumber;
+
+  if (shouldPrintPassNumbers())
+    dbgs() << "Running pass " << CurrentPassNumber << " " << PassID << "\n";
+
+  StringRef PassName = PIC->getPassNameForClassName(PassID);
+  if (!shouldPrintAfterPass(PassName))
+    return;
+
+  SmallString<20> Banner;
+  if (shouldPrintAtPassNumber())
+    Banner = formatv("*** IR Dump At {0}-{1} on {2} (invalidated) ***",
+                     CurrentPassNumber, PassID, IRName);
+  else 
+    Banner = formatv("*** IR Dump After {0} on {1} (invalidated) ***", 
+                     PassID, IRName);
   dbgs() << Banner << "\n";
   printIR(dbgs(), M);
 }
 
 bool PrintIRInstrumentation::shouldPrintBeforePass(StringRef PassID) {
   if (shouldPrintBeforeAll())
     return true;
 
   StringRef PassName = PIC->getPassNameForClassName(PassID);
   return is_contained(printBeforePasses(), PassName);
 }
 
 bool PrintIRInstrumentation::shouldPrintAfterPass(StringRef PassID) {
   if (shouldPrintAfterAll())
     return true;
 
+  if (shouldPrintAtPassNumber() && CurrentPassNumber == PrintAtPassNumber)
+    return true;
+
   StringRef PassName = PIC->getPassNameForClassName(PassID);
   return is_contained(printAfterPasses(), PassName);
 }
 
+bool PrintIRInstrumentation::shouldPrintPassNumbers() {
+  return PrintPassNumbers;
+}
+
+bool PrintIRInstrumentation::shouldPrintAtPassNumber() {
+  return PrintAtPassNumber > 0;
+}
+
 void PrintIRInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   this->PIC = &PIC;
 
   // BeforePass callback is not just for printing, it also saves a Module
   // for later use in AfterPassInvalidated.
-  if (shouldPrintBeforeSomePass() || shouldPrintAfterSomePass())
+  if (shouldPrintPassNumbers() || shouldPrintAtPassNumber() ||
+      shouldPrintBeforeSomePass() || shouldPrintAfterSomePass())
     PIC.registerBeforeNonSkippedPassCallback(
         [this](StringRef P, Any IR) { this->printBeforePass(P, IR); });
 
-  if (shouldPrintAfterSomePass()) {
+  if (shouldPrintPassNumbers() || shouldPrintAtPassNumber() ||
+      shouldPrintAfterSomePass()) {
     PIC.registerAfterPassCallback(
         [this](StringRef P, Any IR, const PreservedAnalyses &) {
           this->printAfterPass(P, IR);
         });
     PIC.registerAfterPassInvalidatedCallback(
         [this](StringRef P, const PreservedAnalyses &) {
           this->printAfterPassInvalidated(P);
         });

llvm/test/Other/print-at-pass-number.ll

+; RUN: opt -passes="loop(indvars,loop-deletion,loop-unroll-full)" -print-pass-numbers -S -o /dev/null %s 2>&1 | FileCheck %s --check-prefix=NUMBER
+; RUN: opt -passes="loop(indvars,loop-deletion,loop-unroll-full)" -print-module-scope -print-at-pass-number=3 -S -o /dev/null %s 2>&1 | FileCheck %s --check-prefix=AT
+; RUN: opt -passes="loop(indvars,loop-deletion,loop-unroll-full)" -print-module-scope -print-at-pass-number=10 -S -o /dev/null %s 2>&1 | FileCheck %s --check-prefix=NONE --allow-empty
+
+define i32 @bar(i32 %arg) {
+; AT: *** IR Dump At 3-IndVarSimplifyPass on bb1 ***
+; AT: define i32 @bar(i32 %arg) {
+
+; NONE-NOT: *** IR Dump At 10
+; NONE-NOT: define i32 @bar(i32 %arg) {
+
+bb:
+  br label %bb1
+
+bb1:                                              ; preds = %bb1, %bb
+  %phi = phi i32 [ 0, %bb ], [ %add, %bb1 ]
+  %phi2 = phi i32 [ 0, %bb ], [ %add3, %bb1 ]
+  %add = add i32 %phi, 1
+  %add3 = add i32 %phi2, %add
+  %icmp = icmp slt i32 %phi, %arg
+  br i1 %icmp, label %bb1, label %bb4
+
+bb4:                                              ; preds = %bb1
+  ret i32 %add3
+}
+
+; NUMBER: Running pass 1 LoopSimplifyPass
+; NUMBER-NEXT: Running pass 2 LCSSAPass
+; NUMBER-NEXT: Running pass 3 IndVarSimplifyPass
+; NUMBER-NEXT: Running pass 4 LoopDeletionPass
+; NUMBER-NEXT: Running pass 5 VerifierPass
+; NUMBER-NEXT: Running pass 6 PrintModulePass