[NewPM] Print pre-transformation IR name in --print-after-all

[aeubanks]

Summary

Sometimes a transformation can change the name of some IR (e.g. an SCC
with functions added/removed). This can be confusing when debug logging
doesn't match the post-transformation name. The specific example I came
across was that --print-after-all said the inliner was working on an SCC
that only contained one function, but calls in multiple functions were
getting inlined. After all inlining, the current SCC only contained one
function.

Piggyback off of the existing logic to handle invalidated IR +
--print-module-scope. Simply always store the IR description and use
that.

[jamieschmeiser]

LGTM

llvm/include/llvm/Passes/StandardInstrumentations.h

private:
 
   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;
-  bool StoreModuleDesc = false;
 };
 
 class OptNoneInstrumentation {
 public:
   OptNoneInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 private:

llvm/lib/Passes/StandardInstrumentations.cpp

bool ChangedIRComparer::generateFunctionData(ChangedIRData &Data,
   return false;
 }
 
 PrintIRInstrumentation::~PrintIRInstrumentation() {
   assert(ModuleDescStack.empty() && "ModuleDescStack is not empty at exit");
 }
 
 void PrintIRInstrumentation::pushModuleDesc(StringRef PassID, Any IR) {
-  assert(StoreModuleDesc);
   const Module *M = unwrapModule(IR);
   ModuleDescStack.emplace_back(M, getIRName(IR), PassID);
 }
 
 PrintIRInstrumentation::PrintModuleDesc
 PrintIRInstrumentation::popModuleDesc(StringRef PassID) {
   assert(!ModuleDescStack.empty() && "empty ModuleDescStack");
   PrintModuleDesc ModuleDesc = ModuleDescStack.pop_back_val();
   assert(std::get<2>(ModuleDesc).equals(PassID) && "malformed ModuleDescStack");
   return ModuleDesc;
 }
 
 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 (StoreModuleDesc && shouldPrintAfterPass(PassID))
+  if (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))
     return;
 
-  if (StoreModuleDesc) {
-    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 " << getIRName(IR)
-         << " ***\n";
+  dbgs() << "*** IR Dump After " << PassID << " on " << IRName << " ***\n";
   unwrapAndPrint(dbgs(), IR);
 }
 
 void PrintIRInstrumentation::printAfterPassInvalidated(StringRef PassID) {
   StringRef PassName = PIC->getPassNameForClassName(PassID);
-  if (!StoreModuleDesc || !shouldPrintAfterPass(PassName))
+  if (!shouldPrintAfterPass(PassName))
     return;
 
   if (isIgnored(PassID))
     return;
 
   const Module *M;
   std::string IRName;
   StringRef StoredPassID;

 }
 
 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.
-  StoreModuleDesc = forcePrintModuleIR() && shouldPrintAfterSomePass();
-  if (shouldPrintBeforeSomePass() || StoreModuleDesc)
+  if (shouldPrintBeforeSomePass() || shouldPrintAfterSomePass())
     PIC.registerBeforeNonSkippedPassCallback(
         [this](StringRef P, Any IR) { this->printBeforePass(P, IR); });
 
   if (shouldPrintAfterSomePass()) {
     PIC.registerAfterPassCallback(
         [this](StringRef P, Any IR, const PreservedAnalyses &) {
           this->printAfterPass(P, IR);
         });

llvm/test/Other/loop-deletion-printer.ll

 ; Make sure that Loop which was invalidated by loop-deletion
 ; does not lead to problems for -print-after-all and is just skipped.
 ;
 ; RUN: opt < %s -disable-output \
 ; RUN:     -passes=loop-instsimplify -print-after-all  2>&1 | FileCheck %s -check-prefix=SIMPLIFY
 ; RUN: opt < %s -disable-output \
 ; RUN:     -passes=loop-deletion,loop-instsimplify -print-after-all  2>&1 | FileCheck %s -check-prefix=DELETED
 ; RUN: opt < %s -disable-output \
-; RUN:     -passes=loop-deletion,loop-instsimplify -print-after-all -print-module-scope  2>&1 | FileCheck %s -check-prefix=DELETED-BUT-PRINTED
+; RUN:     -passes=loop-deletion,loop-instsimplify -print-after-all -print-module-scope  2>&1 | FileCheck %s -check-prefix=DELETED
 ;
 ; SIMPLIFY: IR Dump {{.*}} LoopInstSimplifyPass
+; DELETED: IR Dump {{.*}}LoopDeletionPass {{.*}}(invalidated)
 ; DELETED-NOT: IR Dump {{.*}}LoopInstSimplifyPass
-; DELETED-NOT: IR Dump {{.*}}LoopDeletionPass
-; DELETED-BUT-PRINTED: IR Dump {{.*}}LoopDeletionPass {{.*}}(invalidated)
-; DELETED-BUT-PRINTED-NOT: IR Dump {{.*}}LoopInstSimplifyPass
 
 define void @deleteme() {
 entry:
   br label %loop
 loop:
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
   %iv.next = add i32 %iv, 1
   %check = icmp ult i32 %iv.next, 3
   br i1 %check, label %loop, label %exit
 exit:
   ret void
 }
 

llvm/test/Other/scc-deleted-printer.ll

 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -passes=inline -print-before-all -print-after-all | FileCheck %s -check-prefix=INL
+; RUN:     -passes=inline -print-before-all -print-after-all | FileCheck %s
 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -passes=inline -print-before-all -print-after-all -print-module-scope | FileCheck %s -check-prefix=INL-MOD
+; RUN:     -passes=inline -print-before-all -print-after-all -print-module-scope | FileCheck %s
 
-; INL: IR Dump Before InlinerPass on (tester, foo)
-; INL-NOT: IR Dump After {{InlinerPass}}
-; INL: IR Dump Before InlinerPass on (tester)
-; INL: IR Dump After InlinerPass on (tester)
-
-; INL-MOD: IR Dump Before InlinerPass on (tester, foo)
-; INL-MOD: IR Dump After InlinerPass on (tester, foo) (invalidated)
-; INL-MOD: IR Dump Before InlinerPass on (tester)
-; INL-MOD: IR Dump After InlinerPass on (tester)
+; CHECK: IR Dump Before InlinerPass on (tester, foo)
+; CHECK: IR Dump After InlinerPass on (tester, foo) (invalidated)
+; CHECK: IR Dump Before InlinerPass on (tester)
+; CHECK: IR Dump After InlinerPass on (tester)
 
 
 define void @tester() noinline {
   call void @foo()
   ret void
 }
 
 define internal void @foo() alwaysinline {
   call void @tester()
   ret void
 }