[NewPM] implement SCC printing for -print-before-all/-print-after-all

[fedor.sergeev]

Summary

Removing deficiency of initial implementation of -print-before-all/-after-all - it was effectively skipping IR printing for all the SCC passes.
Now LazyCallGraph:SCC gets its IR printed.

[skatkov]

lib/Passes/StandardInstrumentations.cpp

40

what about CallGraphSCC?
I seen an implementation for LazyCakkGraph but do not see for CallGraphSCC?

61

indent

76

break;

[philip.pfaffe]

What was the deficiency of the initial implementation this is fixing?

[fedor.sergeev]

clang-formatted

[fedor.sergeev]

lib/Passes/StandardInstrumentations.cpp

40

CallGraphSCC is a legacy thing for legacy CallGraphSCCPass.
Attempt to call unwrapAndPrint with anything other than new-pm IRUnits will lead to llvm-unreachable at the end of this function.

[skatkov]

lib/Passes/StandardInstrumentations.cpp

75

Still believe you could do break in case you found a module.

[fedor.sergeev]

addressing the remaining comment

[philip.pfaffe]

So is this just a bugfix? Or does it add functionality?

[fedor.sergeev]

It is a bugfix that adds missing functionality of actually printing an SCC. :)
When doing initial implementation I got a wrong assumption that SCC does not need to be printed since it will be printed on Function level.
For actual SCC passes this assumption is clearly wrong. And it gets fixed now.

lib/Passes/StandardInstrumentations.cpp

 
 //===----------------------------------------------------------------------===//
 // IR-printing instrumentation
 //===----------------------------------------------------------------------===//
 
 /// Generic IR-printing helper that unpacks a pointer to IRUnit wrapped into
 /// llvm::Any and does actual print job.
 void unwrapAndPrint(StringRef Banner, Any IR) {
-  if (any_isa<const CallGraphSCC *>(IR) ||
-      any_isa<const LazyCallGraph::SCC *>(IR))
-    return;
-
   SmallString<40> Extra{"\n"};
   const Module *M = nullptr;
   if (any_isa<const Module *>(IR)) {
     M = any_cast<const Module *>(IR);
   } else if (any_isa<const Function *>(IR)) {
     const Function *F = any_cast<const Function *>(IR);
     if (!llvm::isFunctionInPrintList(F->getName()))
       return;
     if (!llvm::forcePrintModuleIR()) {
       dbgs() << Banner << Extra << static_cast<const Value &>(*F);
       return;
     }
     M = F->getParent();
     Extra = formatv(" (function: {0})\n", F->getName());
+  } else if (any_isa<const LazyCallGraph::SCC *>(IR)) {
+    const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
+    assert(C);
+    if (!llvm::forcePrintModuleIR()) {
+      Extra = formatv(" (scc: {0})\n", C->getName());
+      bool BannerPrinted = false;
+      for (const LazyCallGraph::Node &N : *C) {
+  const Function& F = N.getFunction();
+  if (!F.isDeclaration() && isFunctionInPrintList(F.getName())) {
+    if (!BannerPrinted) {
+      dbgs() << Banner << Extra;
+      BannerPrinted = true;
+    }
+    F.print(dbgs());
+  }
+      }
+      return;
+    }
+    for (const LazyCallGraph::Node &N : *C) {
+      const Function& F = N.getFunction();
+      if (!F.isDeclaration() && isFunctionInPrintList(F.getName()))
+  M = F.getParent();
+    }
+    if (!M)
+      return;
+    Extra = formatv(" (for scc: {0})\n", C->getName());
   } else if (any_isa<const Loop *>(IR)) {
     const Loop *L = any_cast<const Loop *>(IR);
     const Function *F = L->getHeader()->getParent();
     if (!isFunctionInPrintList(F->getName()))
       return;
     if (!llvm::forcePrintModuleIR()) {
       llvm::printLoop(const_cast<Loop &>(*L), dbgs(), Banner);
       return;

test/Other/scc-pass-printer.ll

+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -inline -print-after-all | FileCheck %s -check-prefix=INL
+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -passes=inline -print-after-all | FileCheck %s -check-prefix=INL
+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -inline -print-after-all -print-module-scope | FileCheck %s -check-prefix=INL-MOD
+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -passes=inline -print-after-all -print-module-scope | FileCheck %s -check-prefix=INL-MOD
+
+; INL: IR Dump After {{Function Integration/Inlining|InlinerPass .*scc: .bar, foo}}
+; INL: define void @bar()
+; INL-NEXT:  call void @foo()
+; INL: define void @foo()
+; INL-NEXT:   call void @bar()
+; INL: IR Dump After {{Function Integration/Inlining|InlinerPass .*scc: .tester}}
+; INL: define void @tester()
+; INL-NEXT:  call void @foo()
+; INL: IR Dump After
+
+; INL-MOD: IR Dump After {{Function Integration/Inlining|InlinerPass .*scc: .bar, foo}}
+; INL-MOD: define void @tester()
+; INL-MOD-NEXT:  call void @foo()
+; INL-MOD: define void @foo()
+; INL-MOD-NEXT:   call void @bar()
+; INL-MOD: define void @bar()
+; INL-MOD-NEXT:  call void @foo()
+; INL-MOD: IR Dump After {{Function Integration/Inlining|InlinerPass .*scc: .tester}}
+; INL-MOD: define void @tester()
+; INL-MOD-NEXT:  call void @foo()
+; INL-MOD: define void @foo()
+; INL-MOD-NEXT:   call void @bar()
+; INL-MOD: define void @bar()
+; INL-MOD-NEXT:  call void @foo()
+; INL-MOD: IR Dump After
+
+define void @tester() noinline {
+  call void @foo()
+  ret void
+}
+
+define void @foo() noinline {
+  call void @bar()
+  ret void
+}
+
+define void @bar() noinline {
+  call void @foo()
+  ret void
+}