Single function IR dump

[Gerolf]

Summary

Dumping the IR of an entire module can take a long time. I found a
patch I wrote a while back that allows me to dump the IR for one function.
It is not pretty but gets the job done. You might find it useful and/or have ideas
to improve it etc.

LTO usage example: -Wl,-mllvm,-dump-function=foo -Wl,-mllvm,-mdump-function=foo
-Wl,-mllvm,-print-before-all

[echristo]

Does seem useful in a few limited cases, one comment - you do know about
llvm-extract right? I see this being useful when debugging cross module
type of optimizations etc, but you can run most of a set of passes on a
module with llvm-extract after you take the function out as well.

lib/Analysis/IPA/CallGraphSCCPass.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "cgscc-passmgr"
 
-static cl::opt<unsigned> 
-MaxIterations("max-cg-scc-iterations", cl::ReallyHidden, cl::init(4));
+static cl::opt<unsigned> MaxIterations("max-cg-scc-iterations",
+                                       cl::ReallyHidden, cl::init(4));
 
 STATISTIC(MaxSCCIterations, "Maximum CGSCCPassMgr iterations on one SCC");
 
+extern llvm::cl::opt<std::string> DumpFunction;
 //===----------------------------------------------------------------------===//
 // CGPassManager
 //
 /// CGPassManager manages FPPassManagers and CallGraphSCCPasses.
 
 namespace {
 
 class CGPassManager : public ModulePass, public PMDataManager {

 //===----------------------------------------------------------------------===//
 
 namespace {
   /// PrintCallGraphPass - Print a Module corresponding to a call graph.
   ///
   class PrintCallGraphPass : public CallGraphSCCPass {
     std::string Banner;
     raw_ostream &Out;       // raw_ostream to print on.
-    
   public:
     static char ID;
     PrintCallGraphPass(const std::string &B, raw_ostream &o)
       : CallGraphSCCPass(ID), Banner(B), Out(o) {}
 
     void getAnalysisUsage(AnalysisUsage &AU) const override {
       AU.setPreservesAll();
     }
 
     bool runOnSCC(CallGraphSCC &SCC) override {
-      Out << Banner;
+      bool PrintedBanner = false;
+
       for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
-        if ((*I)->getFunction())
+        if ((*I)->getFunction()) {
+          if (DumpFunction.empty() ||
+              DumpFunction.data() == (*I)->getFunction()->getName()) {
+            if (!PrintedBanner) {
+              PrintedBanner = true;
+              Out << Banner;
+            }
             (*I)->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

 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Timer.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "loop-pass-manager"
 
+extern llvm::cl::opt<std::string> DumpFunction;
+
 namespace {
 
 /// PrintLoopPass - Print a Function corresponding to a Loop.
 ///
 class PrintLoopPass : public LoopPass {
 private:
   std::string Banner;
   raw_ostream &Out;       // raw_ostream to print on.
 
 public:
   static char ID;
   PrintLoopPass(const std::string &B, raw_ostream &o)
       : LoopPass(ID), Banner(B), Out(o) {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   bool runOnLoop(Loop *L, LPPassManager &) override {
-    Out << Banner;
+    bool PrintedBanner = false;
     for (Loop::block_iterator b = L->block_begin(), be = L->block_end();
          b != be;
          ++b) {
-      if (*b)
+      if (*b) {
+        if (DumpFunction.empty() ||
+            DumpFunction.data() == (*b)->getParent()->getName()) {
+          if (!PrintedBanner) {
+            PrintedBanner = true;
+            Out << Banner;
+          }
           (*b)->print(Out);
-      else
+        }
+      } else
         Out << "Printing <null> block";
     }
     return false;
   }
 };
 
 char PrintLoopPass::ID = 0;
 }

lib/CodeGen/MachineFunction.cpp

 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 using namespace llvm;
+extern llvm::cl::opt<std::string> MDumpFunction;
 
 #define DEBUG_TYPE "codegen"
 
 //===----------------------------------------------------------------------===//
 // MachineFunction implementation
 //===----------------------------------------------------------------------===//
 
 // Out of line virtual method.

 
 StringRef MachineFunction::getName() const {
   assert(getFunction() && "No function!");
   return getFunction()->getName();
 }
 
 void MachineFunction::print(raw_ostream &OS, SlotIndexes *Indexes) const {
   OS << "# Machine code for function " << getName() << ": ";
+  if (!MDumpFunction.empty() && MDumpFunction.data() != getName())
+    return;
   if (RegInfo) {
     OS << (RegInfo->isSSA() ? "SSA" : "Post SSA");
     if (!RegInfo->tracksLiveness())
       OS << ", not tracking liveness";
   }
   OS << '\n';
 
   // Print Frame Information

lib/CodeGen/MachineFunctionPrinterPass.cpp

 // MachineFunctionPrinterPass implementation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/SlotIndexes.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
+cl::opt<std::string> MDumpFunction("mdump-function", cl::init(""),
+                                   cl::value_desc("function names"),
+                                   cl::desc("Dump IR for the function only"));
 
 namespace {
 /// MachineFunctionPrinterPass - This is a pass to dump the IR of a
 /// MachineFunction.
 ///
 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) 
       : 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 (MDumpFunction.empty() || MDumpFunction.data() == MF.getName()) {
       OS << "# " << Banner << ":\n";
       MF.print(OS, getAnalysisIfAvailable<SlotIndexes>());
+    }
     return false;
   }
 };
 
 char MachineFunctionPrinterPass::ID = 0;
 }
 
 char &llvm::MachineFunctionPrinterPassID = MachineFunctionPrinterPass::ID;

lib/IR/IRPrintingPasses.cpp

 //===--- IRPrintingPasses.cpp - Module and Function printing passes -------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // PrintModulePass and PrintFunctionPass implementations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/IRPrintingPasses.h"
+//#include "llvm/IR/IRPrintOptions.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
+cl::opt<std::string> DumpFunction("dump-function", cl::init(""),
+                                  cl::value_desc("function names"),
+                                  cl::desc("Dump IR for the function only"));
+
 PrintModulePass::PrintModulePass() : OS(dbgs()) {}
 PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner)
     : OS(OS), Banner(Banner) {}
 
 PreservedAnalyses PrintModulePass::run(Module *M) {
   OS << Banner << *M;
   return PreservedAnalyses::all();
 }

 
 public:
   static char ID;
   PrintModulePassWrapper() : ModulePass(ID) {}
   PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner)
       : ModulePass(ID), P(OS, Banner) {}
 
   bool runOnModule(Module &M) override {
+    if (DumpFunction.empty())
       P.run(&M);
     return false;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 };
 
 class PrintFunctionPassWrapper : public FunctionPass {
   PrintFunctionPass P;
 
 public:
   static char ID;
   PrintFunctionPassWrapper() : FunctionPass(ID) {}
   PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
       : FunctionPass(ID), P(OS, Banner) {}
 
   // This pass just prints a banner followed by the function as it's processed.
   bool runOnFunction(Function &F) override {
+    if (DumpFunction.empty() || DumpFunction.data() == F.getName())
       P.run(&F);
     return false;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 };
 
 class PrintBasicBlockPass : public BasicBlockPass {
   raw_ostream &Out;
   std::string Banner;
 
 public:
   static char ID;
   PrintBasicBlockPass() : BasicBlockPass(ID), Out(dbgs()) {}
   PrintBasicBlockPass(raw_ostream &Out, const std::string &Banner)
       : BasicBlockPass(ID), Out(Out), Banner(Banner) {}
 
   bool runOnBasicBlock(BasicBlock &BB) override {
+    if (DumpFunction.empty() ||
+        DumpFunction.data() == BB.getParent()->getName())
       Out << Banner << BB;
     return false;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 };