IR printing improvement for function passes - introducing -print-module-scope

[fedor.sergeev]

Summary

When debugging function passes it happens to be rather useful to dump
the whole module before the transformation and then use this dump
to analyze this single transformation by running it separately
on that particular module state.

Introducing

-print-module-scope

debugging option that forces all the function-level IR dumps
to become whole-module dumps.

This option builds on top of normal dumping controls like

-print-before/after
-filter-print-funcs

The plan is to eventually extend this option to cover other local passes
(at least loop passes) but that should go as a separate change.

[fedor.sergeev]

ping?

[weimingz]

In D40245#940424, @fedor.sergeev wrote:

ping?

since https://reviews.llvm.org/D40247 is approved, this patch looks good.

[fedor.sergeev]

I assume this was approved!

include/llvm/Pass.h

 /// @brief This is the storage for the -time-passes option.
 extern bool TimePassesIsEnabled;
 
 /// isFunctionInPrintList - returns true if a function should be printed via
 //  debugging options like -print-after-all/-print-before-all.
 //  @brief Tells if the function IR should be printed by PrinterPass.
 extern bool isFunctionInPrintList(StringRef FunctionName);
 
+/// forcePrintModuleIR - returns true if IR printing passes should
+//  be printing module IR (even for local-pass printers e.g. function-pass)
+//  to provide more context, as enabled by debugging option -print-module-scope
+//  @brief Tells if IR printer should be printing module IR
+extern bool forcePrintModuleIR();
+
 } // end namespace llvm
 
 // Include support files that contain important APIs commonly used by Passes,
 // but that we want to separate out to make it easier to read the header files.
 #include "llvm/InitializePasses.h"
 #include "llvm/PassAnalysisSupport.h"
 #include "llvm/PassSupport.h"
 
 #endif // LLVM_PASS_H

lib/IR/IRPrintingPasses.cpp

 
 PrintFunctionPass::PrintFunctionPass() : OS(dbgs()) {}
 PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
     : OS(OS), Banner(Banner) {}
 
 PreservedAnalyses PrintFunctionPass::run(Function &F,
                                          FunctionAnalysisManager &) {
   if (isFunctionInPrintList(F.getName()))
+    if (forcePrintModuleIR())
+      OS << Banner << " (function: " << F.getName() << ")\n" << *F.getParent();
+    else
       OS << Banner << static_cast<Value &>(F);
   return PreservedAnalyses::all();
 }
 
 namespace {
 
 class PrintModulePassWrapper : public ModulePass {
   PrintModulePass P;
 

lib/IR/LegacyPassManager.cpp

 PrintBeforeAll("print-before-all",
                llvm::cl::desc("Print IR before each pass"),
                cl::init(false));
 static cl::opt<bool>
 PrintAfterAll("print-after-all",
               llvm::cl::desc("Print IR after each pass"),
               cl::init(false));
 
+static cl::opt<bool>
+    PrintModuleScope("print-module-scope",
+                     cl::desc("When printing IR for print-[before|after]{-all} "
+                              "always print a module IR"),
+                     cl::init(false));
+
 static cl::list<std::string>
     PrintFuncsList("filter-print-funcs", cl::value_desc("function names"),
                    cl::desc("Only print IR for functions whose name "
                             "match this for all print-[before|after][-all] "
                             "options"),
                    cl::CommaSeparated);
 
 /// This is a helper to determine whether to print IR before or

 }
 
 /// This is a utility to check whether a pass should have IR dumped
 /// after it.
 static bool ShouldPrintAfterPass(const PassInfo *PI) {
   return PrintAfterAll || ShouldPrintBeforeOrAfterPass(PI, PrintAfter);
 }
 
+bool llvm::forcePrintModuleIR() { return PrintModuleScope; }
+
 bool llvm::isFunctionInPrintList(StringRef FunctionName) {
   static std::unordered_set<std::string> PrintFuncNames(PrintFuncsList.begin(),
                                                         PrintFuncsList.end());
   return PrintFuncNames.empty() || PrintFuncNames.count(FunctionName);
 }
 /// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions
 /// or higher is specified.
 bool PMDataManager::isPassDebuggingExecutionsOrMore() const {

test/Other/print-module-scope.ll

+; This test is checking basic properties of -print-module-scope options:
+;   - dumps all the module IR at once
+;   - all the function attributes are shown, including those of declarations
+;   - works on top of -print-after and -filter-print-funcs
+;
+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -simplifycfg -print-after=simplifycfg -print-module-scope \
+; RUN:     | FileCheck %s -check-prefix=CFG
+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -simplifycfg -print-after=simplifycfg -filter-print-funcs=foo -print-module-scope \
+; RUN:     | FileCheck %s -check-prefix=FOO
+
+; CFG:      IR Dump After
+; CFG-SAME:   function: foo
+; CFG-NEXT: ModuleID =
+; CFG: define void @foo
+; CFG: define void @bar
+; CFG: declare void @baz
+; CFG: IR Dump After
+; CFG-SAME:   function: bar
+; CFG-NEXT: ModuleID =
+; CFG: define void @foo
+; CFG: define void @bar
+; CFG: declare void @baz
+
+; FOO:      IR Dump After
+; FOO-NOT:    function: bar
+; FOO-SAME:   function: foo
+; FOO-NEXT: ModuleID =
+; FOO:   Function Attrs: nounwind ssp
+; FOO: define void @foo
+; FOO:   Function Attrs: nounwind
+; FOO: define void @bar
+; FOO:   Function Attrs: nounwind readnone ssp
+; FOO: declare void @baz
+
+define void @foo() nounwind ssp {
+  call void @baz()
+  ret void
+}
+
+define void @bar() #0 {
+  ret void
+}
+
+declare void @baz() #1
+
+attributes #0 = { nounwind "no-frame-pointer-elim"="true" }
+
+attributes #1 = { nounwind readnone ssp "use-soft-float"="false" }
+; FOO: attributes #{{[0-9]}} = { nounwind "no-frame-pointer-elim"="true" }
+
+; FOO: attributes #{{[0-9]}} = { nounwind readnone ssp "use-soft-float"="false" }
+
+; FOO-NOT: IR Dump