Filtering IR printing for print-after-all/print-before-all

[weimingz]

Summary

This patch implements "-print-funcs" option to support function filtering for IR printing like -print-after-all, -print-before etc.
Examples:

-print-after-all -print-funcs=foo,bar

[mehdi_amini]

Thanks for working on this, I thought about this multiple times, but never got to implement it. Some comments below.

include/llvm/Pass.h

372

Document

lib/Analysis/LoopPass.cpp

45–49

What if we don't have a header? When does it happen? Can this inhibit the print of a loop even when -print-funcs isn't supplied?
Else, could it be an assert instead?

lib/CodeGen/MachineFunctionPrinterPass.cpp

48

Early return is preferred (same for all the similar cases).

lib/IR/IRPrintingPasses.cpp

34

What about having the else here looping over the module and finding the functions selected to be printed and print them?

lib/IR/LegacyPassManager.cpp

514

Not sure if this is the right place to do that, what about a static variable local to isFunctionInPrintList(), it would be initialized on the first call to the function.

[tejohnson]

Agree with Mehdi, this will be very useful. Thanks!

lib/Analysis/CallGraphSCCPass.cpp

616

Combine above two ifs into a single "if (A && B)".

lib/IR/IRPrintingPasses.cpp

34

Agree here with Mehdi. Rather than have an all-or-nothing printing of the module under a special "*" string, it would be better to walk the module and print just the functions in the list. Otherwise to get any printing before/after module passes you run into the same issue with huge amounts of output for large modules. This would also be analogous to what you are doing for SCC passes (printing just the functions in the SCC that are in the list).

lib/IR/LegacyPassManager.cpp

90

Remove the "*" special case as described earlier.

[weimingz]

lib/Analysis/CallGraphSCCPass.cpp

616

If we combine them, then for non-null function but not in our filter list, it will output "Printing <null> Function"

lib/Analysis/LoopPass.cpp

45–49

normally we wouldn't hit this.
But since there could be null blocks (see LoopInfo.cpp PrinterLoopPass::run() ), I added a check. If the code is broken, it should be caught by other passes. :D

lib/IR/IRPrintingPasses.cpp

34

Agree. I will add "*" to the list if we don't specify anything to filter. So by testing "*", we can tell if the Option is empty or not.
For SCC, it already has a loop.

[mehdi_amini]

lib/Analysis/LoopPass.cpp

45–50

Not clear to me: either there is a valid use case where PrintLoopPassWrapper::runOnLoop() is called with getHeader() returning null or not, can you clarify?

In the absence of such valid case, please turn this into an assert or just remove the check.

lib/IR/LegacyPassManager.cpp

128

Is it possible to write it:

static std::set<std::string> PrintFuncNames(PrintFuncsList.begin(), PrintFuncsList.end());

?

Also, why not an unordered_set?

131

I'm not sure I see the need for the "*" in the set? The empty case returning true seems enough to me to provide exactly the same behavior.

[weimingz]

lib/Analysis/LoopPass.cpp

45–50

Could be a valid case. Below is PrintLoopPass::run()
PrintLoopPass::run(Loop &L) {

 ..
for (auto *Block : L.blocks())
  if (Block)
    Block->print(OS);
  else
    OS << "Printing <null> block";

..
}

lib/IR/LegacyPassManager.cpp

128

Yes, we can write in one line.

yes, I meant to use unordered_set, but forgot the change. Thanks!

131

Need that because in Module print, we need to test if the filter-list is empty or not. (An empty list means the whole module will be printed).

isFunctionInPrintList() only checks if the argument string is in the list or not. Alternatively, we can let it return a pair of bools, one indicates if the list is empty or not, the other tells if the arg is in list or not. But this is not intuitive.

[tejohnson]

lib/Analysis/CallGraphSCCPass.cpp

616

Oh I see, we don't want to print anything when the function is suppressed. Nevermind my suggestion then.

lib/IR/LegacyPassManager.cpp

131

How about just return true when PrintFuncNames is empty? I see you are currently using that condition to guard initialization. You can either add a different static bool to indicate that it was already initialized, or key off of PrintFuncsList being non-empty to guard the initialization.

Then you don't need the special case in PrintModulePass::run either.

[weimingz]

lib/IR/LegacyPassManager.cpp

125

Module printing is different. It not just prints each functions but also others like meta, GV, triple, etc. By default (not specify anything on the filter list), it should print all those stuff.

So we need two functionalities: 1) tell if some function is in list or not; 2) tell if we specified anything to the list.

[mehdi_amini]

lib/Analysis/LoopPass.cpp

45–50

I see, but it means that here we shouldn't check for the header but get the first valid block to get the function, something like:

auto FirstValidBlockInLoop = std::find_if(L.blocks().start(), L.blocks().end(), [] (BasicBlock *Block) { return Block; });
if (FirstValidBlockInLoop != L.blocks().end() && 
    isFunctionInPrintList(FirstValidBlockInLoop->getParent()->getName()))
      P.run(*L);

lib/IR/LegacyPassManager.cpp

125

You don't need to add "*" to the set to have the empty case working since in the empty case true is returned for anything.

[mehdi_amini]

lib/IR/LegacyPassManager.cpp

125

To be more clear, I don't see why this wouldn't work:

bool llvm::isFunctionInPrintList(StringRef FunctionName) {
  static std::unordered_set<std::string> PrintFuncNames(PrintFuncsList.begin(),
                                                        PrintFuncsList.end());

  if (PrintFuncNames.empty())
    return true;

  return PrintFuncNames.count(FunctionName);
}

[mehdi_amini]

lib/IR/LegacyPassManager.cpp

90

Just thought about this, we already have something to filter basic blocks in the DAG output, and the option is named filter-view-dags, so I feel this option should also start with filter for consistency.

[weimingz]

lib/IR/LegacyPassManager.cpp

90

Agree. Will change it to -filter-print-funcs

125

In Module print, we have 2 cases to handle now:

1. the default case / the filter list is empty(): M.print(OS, nullptr, ShouldPreserveUseListOrder); // this will dump all module info
2. the list is non empty. No GV, meta info will be output and only functions in the filter list will be printed.

The code you show either dumps all funcs if list is empty or dump filtered funcs. But it doesn't differentiate case 1 and case 2.

[mehdi_amini]

lib/IR/LegacyPassManager.cpp

125

What about:

bool llvm::isFunctionInPrintList(StringRef FunctionName) {
  static std::unordered_set<std::string> PrintFuncNames(PrintFuncsList.begin(),
                                                        PrintFuncsList.end());

  if (PrintFuncNames.empty())
    return true;

  return PrintFuncNames.count(FunctionName) || PrintFuncNames.count("*");
}

[mehdi_amini]

lib/IR/LegacyPassManager.cpp

125

Nevermind forget my last comment, I still don't see any use for that. I still don't get your use case.

Can you provide an input where it differs?

[weimingz]

lib/IR/LegacyPassManager.cpp

125

For example, when the filter-list is empty. the whole module info is expected.
So in lib/IR/IRPrintingPasses.cpp, we should call

M.print(...);

The loop below should be run only when the filter list is not empty:

for(const auto &F : M.functions())
 if (llvm::isFunctionInPrintList(F.getName()))  // Although it can return T if filter list is empty, but we don't want to just print function level IRs
     F.print(OS);

[mehdi_amini]

lib/IR/LegacyPassManager.cpp

125

I understand that, I just don't see why it does not work with the implementation I gave you.

Can we focus on isFunctionInPrintList() can you give a case where the implementation I gave you does not return true or false as expected?

[weimingz]

LOL. I misunderstood what you said.
Now I got it. Thanks, Mehdi!

[mehdi_amini]

I'm glad we sorted out.
LGTM, thanks.

[weimingz]

Remove an extra "\n" output that causes some lit test fail.

include/llvm/Pass.h

protected:
   bool skipOptnoneFunction(const BasicBlock &BB) const;
 };
 
 /// If the user specifies the -time-passes argument on an LLVM tool command line
 /// then the value of this boolean will be true, otherwise false.
 /// @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);
 } // End llvm namespace
 
 // 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/PassSupport.h"
 #include "llvm/PassAnalysisSupport.h"
 
 #endif

lib/Analysis/CallGraphSCCPass.cpp

public:
 
     void getAnalysisUsage(AnalysisUsage &AU) const override {
       AU.setPreservesAll();
     }
 
     bool runOnSCC(CallGraphSCC &SCC) override {
       Out << Banner;
       for (CallGraphNode *CGN : SCC) {
-        if (CGN->getFunction())
+        if (CGN->getFunction()) {
+          if (isFunctionInPrintList(CGN->getFunction()->getName()))
             CGN->getFunction()->print(Out);
-        else
+        } else
           Out << "\nPrinting <null> Function\n";
       }
       return false;
     }
   };
   
 } // end anonymous namespace.
 
 char PrintCallGraphPass::ID = 0;
 
 Pass *CallGraphSCCPass::createPrinterPass(raw_ostream &O,
                                           const std::string &Banner) const {
   return new PrintCallGraphPass(Banner, O);
 }
 

lib/Analysis/LoopPass.cpp

public:
   PrintLoopPassWrapper(raw_ostream &OS, const std::string &Banner)
       : LoopPass(ID), P(OS, Banner) {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   bool runOnLoop(Loop *L, LPPassManager &) override {
+    auto BBI = find_if(L->blocks().begin(), L->blocks().end(),
+                       [](BasicBlock *BB) { return BB; });
+    if (BBI != L->blocks().end() &&
+        isFunctionInPrintList((*BBI)->getParent()->getName()))
       P.run(*L);
     return false;
   }
 };
 
 char PrintLoopPassWrapper::ID = 0;
 }
 
 //===----------------------------------------------------------------------===//
 // LPPassManager

lib/CodeGen/MachineFunctionPrinterPass.cpp

 ///
 struct MachineFunctionPrinterPass : public MachineFunctionPass {
   static char ID;
 
   raw_ostream &OS;
   const std::string Banner;
 
   MachineFunctionPrinterPass() : MachineFunctionPass(ID), OS(dbgs()) { }
-  MachineFunctionPrinterPass(raw_ostream &os, const std::string &banner) 
+  MachineFunctionPrinterPass(raw_ostream &os, const std::string &banner)
       : MachineFunctionPass(ID), OS(os), Banner(banner) {}
 
   const char *getPassName() const override { return "MachineFunction Printer"; }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
     MachineFunctionPass::getAnalysisUsage(AU);
   }
 
   bool runOnMachineFunction(MachineFunction &MF) override {
+    if (!llvm::isFunctionInPrintList(MF.getName()))
+      return false;
     OS << "# " << Banner << ":\n";
     MF.print(OS, getAnalysisIfAvailable<SlotIndexes>());
     return false;
   }
 };
 
 char MachineFunctionPrinterPass::ID = 0;
 }
 
 char &llvm::MachineFunctionPrinterPassID = MachineFunctionPrinterPass::ID;

lib/IR/IRPrintingPasses.cpp

 
 PrintModulePass::PrintModulePass() : OS(dbgs()) {}
 PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner,
                                  bool ShouldPreserveUseListOrder)
     : OS(OS), Banner(Banner),
       ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
 
 PreservedAnalyses PrintModulePass::run(Module &M) {
-  OS << Banner;
+  OS << Banner << "\n";
+  if (llvm::isFunctionInPrintList("*"))
     M.print(OS, nullptr, ShouldPreserveUseListOrder);
+  else {
+    for(const auto &F : M.functions())
+      if (llvm::isFunctionInPrintList(F.getName()))
+        F.print(OS);
+  }
   return PreservedAnalyses::all();
 }
 
 PrintFunctionPass::PrintFunctionPass() : OS(dbgs()) {}
 PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
     : OS(OS), Banner(Banner) {}
 
 PreservedAnalyses PrintFunctionPass::run(Function &F) {
+  if (isFunctionInPrintList(F.getName()))
     OS << Banner << static_cast<Value &>(F);
   return PreservedAnalyses::all();
 }
 
 namespace {
 
 class PrintModulePassWrapper : public ModulePass {
   PrintModulePass P;
 

lib/IR/LegacyPassManager.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/TimeValue.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <map>
+#include <unordered_set>
 using namespace llvm;
 using namespace llvm::legacy;
 
 // See PassManagers.h for Pass Manager infrastructure overview.
 
 //===----------------------------------------------------------------------===//
 // Pass debugging information.  Often it is useful to find out what pass is
 // running when a crash occurs in a utility.  When this library is compiled with

 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::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
 /// after a pass.
 
 static bool ShouldPrintBeforeOrAfterPass(const PassInfo *PI,
                                          PassOptionList &PassesToPrint) {
   for (auto *PassInf : PassesToPrint) {
     if (PassInf)
       if (PassInf->getPassArgument() == PI->getPassArgument()) {

 }
 
 /// 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::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 {
   return PassDebugging >= Executions;
 }
 
 
 
 
 void PassManagerPrettyStackEntry::print(raw_ostream &OS) const {
   if (!V && !M)
     OS << "Releasing pass '";
   else
     OS << "Running pass '";
 

 //===----------------------------------------------------------------------===//
 // PMTopLevelManager implementation
 
 /// Initialize top level manager. Create first pass manager.
 PMTopLevelManager::PMTopLevelManager(PMDataManager *PMDM) {
   PMDM->setTopLevelManager(this);
   addPassManager(PMDM);
   activeStack.push(PMDM);
 }
 
 /// Set pass P as the last user of the given analysis passes.
 void
 PMTopLevelManager::setLastUser(ArrayRef<Pass*> AnalysisPasses, Pass *P) {
   unsigned PDepth = 0;
   if (P->getResolver())
     PDepth = P->getResolver()->getPMDataManager().getDepth();
 

test/Other/2010-05-06-Printer.ll

 ; RUN: llc -O2 -print-after-all < %s 2>/dev/null
+; RUN: llc -O2 -print-after-all < %s 2>&1 | FileCheck %s --check-prefix=ALL
+; RUN: llc -O2 -print-after-all -filter-print-funcs=foo < %s 2>&1 | FileCheck %s --check-prefix=FOO
 ; REQUIRES: default_triple
-
 define void @tester(){
   ret void
 }
 
+define void @foo(){
+  ret void
+}
+
+;ALL: define void @tester()
+;ALL: define void @foo()
+;ALL: ModuleID =
+
+;FOO: IR Dump After
+;FOO-NEXT: define void @foo()
+;FOO-NOT: define void @tester