[LLVM] Add -git-commit-after-all option

[alexandre.isoard]

Summary

Will create a temporary git and add the entire module LLVM-IR and
commit it, after each passes.

[alexandre.isoard]

Fixed RUN_ON macro typo

[etherzhhb]

include/llvm/IR/GitCommitModule.h

32–33

there is no create...Pass

lib/IR/LegacyPassManager.cpp

739–740

if (auto *PP = P->createGitCommitModulePass(GitRepo, P->getPassName()))

[asb]

For reference, this was discussed on llvm-dev here: http://lists.llvm.org/pipermail/llvm-dev/2018-March/121634.html

My personal view is that it would make more sense to dump the raw information you're after in a trivially machine readable way (a minor modification to -print-after-all?), and use an external script to post-process that output (e.g. committing to git). It might make sense to commit such a script to the utils/ subdir. That would be more general purpose, and avoid the concern of what to do when someone wants to come along and add a HgCommitModule or similar.

[reames]

It was pointed out that upstream support for dumping the whole module already exists. It's spelled as: -print-after-all -print-module-scope

Given this, you should be able to do this by post processing a log without needing any LLVM changes.

include/llvm/Analysis/CallGraphSCCPass.h

 public:
   explicit CallGraphSCCPass(char &pid) : Pass(PT_CallGraphSCC, pid) {}
 
   /// createPrinterPass - Get a pass that prints the Module
   /// corresponding to a CallGraph.
   Pass *createPrinterPass(raw_ostream &OS,
                           const std::string &Banner) const override;
 
+  /// createGitCommitModulePass - Get a git-commit module pass.
+  Pass *createGitCommitModulePass(const std::string &GitRepo,
+                                  const std::string &Message) const override;
+
   using llvm::Pass::doInitialization;
   using llvm::Pass::doFinalization;
 
   /// doInitialization - This method is called before the SCC's of the program
   /// has been processed, allowing the pass to do initialization as necessary.
   virtual bool doInitialization(CallGraph &CG) {
     return false;
   }

include/llvm/Analysis/LoopPass.h

 public:
   explicit LoopPass(char &pid) : Pass(PT_Loop, pid) {}
 
   /// getPrinterPass - Get a pass to print the function corresponding
   /// to a Loop.
   Pass *createPrinterPass(raw_ostream &O,
                           const std::string &Banner) const override;
 
+  /// createGitCommitModulePass - Get a git-commit module pass.
+  Pass *createGitCommitModulePass(const std::string &GitRepo,
+                                  const std::string &Message) const override;
+
   // runOnLoop - This method should be implemented by the subclass to perform
   // whatever action is necessary for the specified Loop.
   virtual bool runOnLoop(Loop *L, LPPassManager &LPM) = 0;
 
   using llvm::Pass::doInitialization;
   using llvm::Pass::doFinalization;
 
   // Initialization and finalization hooks.

include/llvm/Analysis/RegionPass.h

public:
   ///
   /// @param O      The output stream to print the Region.
   /// @param Banner The banner to separate different printed passes.
   ///
   /// @return The pass to print the LLVM IR in the region.
   Pass *createPrinterPass(raw_ostream &O,
                           const std::string &Banner) const override;
 
+  /// createGitCommitModulePass - Get a git-commit module pass.
+  Pass *createGitCommitModulePass(const std::string &GitRepo,
+                                  const std::string &Message) const override;
+
   using llvm::Pass::doInitialization;
   using llvm::Pass::doFinalization;
 
   virtual bool doInitialization(Region *R, RGPassManager &RGM) { return false; }
   virtual bool doFinalization() { return false; }
   //@}
 
   //===--------------------------------------------------------------------===//

include/llvm/IR/GitCommitModule.h

+//===--- GitCommitModule.h --- Write and Commit Module into Git -*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines passes to write out IR and commit it into a Git
+/// repository. The GitCommitModulePass pass simply initialize a Git repository
+/// when created, then write out and commit the entire module when it is
+/// executed.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_GITCOMMITMODULE_H
+#define LLVM_IR_GITCOMMITMODULE_H
+
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include <string>
+
+namespace llvm {
+class Module;
+class PreservedAnalyses;
+template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;
+
+/// \brief Pass for printing and committing a Module as LLVM's text IR assembly.
+///
+/// Note: This pass is for use with the new pass manager. Use the create...Pass
+/// functions above to create passes for use with the legacy pass manager.
+class GitCommitModulePass {
+  SmallString<128> GitRepo;
+  std::string Message;
+  bool ShouldPreserveUseListOrder;
+
+protected:
+  bool init();
+  bool printModule(llvm::Module &M);
+  bool commit();
+
+  llvm::PreservedAnalyses run(Module &M);
+
+public:
+  GitCommitModulePass();
+  GitCommitModulePass(const std::string &GitRepo, const std::string &Message,
+                      bool ShouldPreserveUseListOrder = false);
+
+  llvm::PreservedAnalyses run(Module &M, AnalysisManager<Module> &);
+
+  static llvm::StringRef name() { return "GitCommitModulePass"; }
+};
+} // namespace llvm
+
+// Provides the implementation of the wrapper pass (wrap it into a KindPass).
+//
+// That is split into pieces to handle RegionPass, LoopPass and CallGraphSCCPass
+#define GIT_COMMIT_MODULE_PASS_WRAPPER(Kind, GetModule)                        \
+  GIT_COMMIT_MODULE_PASS_WRAPPER_INTERNAL(                                     \
+      Kind, GetModule, GIT_COMMIT_MODULE_PASS_WRAPPER_RUN_ON)
+#define GIT_COMMIT_MODULE_PASS_WRAPPER_RUN_ON(Kind, K) runOn##Kind(Kind &K)
+#define GIT_COMMIT_MODULE_PASS_WRAPPER_INTERNAL(Kind, GetModule, RUN_ON)       \
+  namespace {                                                                  \
+  class GitCommit##Kind##PassWrapper : public Kind##Pass {                     \
+    GitCommitModulePass P;                                                     \
+                                                                               \
+  public:                                                                      \
+    static char ID;                                                            \
+    GitCommit##Kind##PassWrapper(const std::string &GitRepo,                   \
+                                 const std::string &Message,                   \
+                                 bool ShouldPreserveUseListOrder = false)      \
+        : Kind##Pass(ID), P(GitRepo, Message, ShouldPreserveUseListOrder) {}   \
+                                                                               \
+    bool RUN_ON(Kind, K) override {                                            \
+      ModuleAnalysisManager DummyMAM;                                          \
+      P.run(GetModule(K), DummyMAM);                                           \
+      return false;                                                            \
+    }                                                                          \
+                                                                               \
+    void getAnalysisUsage(AnalysisUsage &AU) const override {                  \
+      AU.setPreservesAll();                                                    \
+    }                                                                          \
+  };                                                                           \
+  }                                                                            \
+  char GitCommit##Kind##PassWrapper::ID = 0;
+
+#endif

include/llvm/Pass.h

public:
 
   void dump() const; // dump - Print to stderr.
 
   /// createPrinterPass - Get a Pass appropriate to print the IR this
   /// pass operates on (Module, Function or MachineFunction).
   virtual Pass *createPrinterPass(raw_ostream &OS,
                                   const std::string &Banner) const = 0;
 
+  /// createGitCommitModulePass - Get a Pass to print and commit the IR
+  /// of the entire module.
+  virtual Pass *createGitCommitModulePass(const std::string &GitRepo,
+                                          const std::string &Message) const = 0;
+
   /// Each pass is responsible for assigning a pass manager to itself.
   /// PMS is the stack of available pass manager.
   virtual void assignPassManager(PMStack &,
                                  PassManagerType) {}
 
   /// Check if available pass managers are suitable for this pass or not.
   virtual void preparePassManager(PMStack &);
 
public:
 
   // Force out-of-line virtual method.
   ~ModulePass() override;
 
   /// createPrinterPass - Get a module printer pass.
   Pass *createPrinterPass(raw_ostream &OS,
                           const std::string &Banner) const override;
 
+  /// createGitCommitModulePass - Get a git-commit module pass.
+  Pass *createGitCommitModulePass(const std::string &GitRepo,
+                                  const std::string &Message) const override;
+
   /// runOnModule - Virtual method overriden by subclasses to process the module
   /// being operated on.
   virtual bool runOnModule(Module &M) = 0;
 
   void assignPassManager(PMStack &PMS, PassManagerType T) override;
 
   ///  Return what kind of Pass Manager can manage this pass.
   PassManagerType getPotentialPassManagerType() const override;

 class FunctionPass : public Pass {
 public:
   explicit FunctionPass(char &pid) : Pass(PT_Function, pid) {}
 
   /// createPrinterPass - Get a function printer pass.
   Pass *createPrinterPass(raw_ostream &OS,
                           const std::string &Banner) const override;
 
+  /// createGitCommitModulePass - Get a git-commit module function pass.
+  Pass *createGitCommitModulePass(const std::string &GitRepo,
+                                  const std::string &Message) const override;
+
   /// runOnFunction - Virtual method overriden by subclasses to do the
   /// per-function processing of the pass.
   virtual bool runOnFunction(Function &F) = 0;
 
   void assignPassManager(PMStack &PMS, PassManagerType T) override;
 
   ///  Return what kind of Pass Manager can manage this pass.
   PassManagerType getPotentialPassManagerType() const override;

 class BasicBlockPass : public Pass {
 public:
   explicit BasicBlockPass(char &pid) : Pass(PT_BasicBlock, pid) {}
 
   /// createPrinterPass - Get a basic block printer pass.
   Pass *createPrinterPass(raw_ostream &OS,
                           const std::string &Banner) const override;
 
+  /// createGitCommitModulePass - Get a git-commit module basic block pass.
+  Pass *createGitCommitModulePass(const std::string &GitRepo,
+                                  const std::string &Message) const override;
+
   using llvm::Pass::doInitialization;
   using llvm::Pass::doFinalization;
 
   /// doInitialization - Virtual method overridden by BasicBlockPass subclasses
   /// to do any necessary per-function initialization.
   virtual bool doInitialization(Function &);
 
   /// runOnBasicBlock - Virtual method overriden by subclasses to do the

lib/Analysis/CallGraphSCCPass.cpp

 
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SCCIterator.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/GitCommitModule.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManagers.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/OptBisect.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"

 
 char PrintCallGraphPass::ID = 0;
 
 Pass *CallGraphSCCPass::createPrinterPass(raw_ostream &OS,
                                           const std::string &Banner) const {
   return new PrintCallGraphPass(Banner, OS);
 }
 
+static Module &getModule(CallGraphSCC &SCC) {
+  return SCC.getCallGraph().getModule();
+}
+
+#define RUN_ON(CallGraphSCC, SCC) runOnSCC(CallGraphSCC &SCC)
+GIT_COMMIT_MODULE_PASS_WRAPPER_INTERNAL(CallGraphSCC, getModule, RUN_ON)
+#undef RUN_ON
+
 bool CallGraphSCCPass::skipSCC(CallGraphSCC &SCC) const {
   return !SCC.getCallGraph().getModule()
               .getContext()
               .getOptBisect()
               .shouldRunPass(this, SCC);
 }
 
+Pass *
+CallGraphSCCPass::createGitCommitModulePass(const std::string &GitRepo,
+                                            const std::string &Message) const {
+  return new GitCommitCallGraphSCCPassWrapper(GitRepo, Message);
+}
+
 char DummyCGSCCPass::ID = 0;
 
 INITIALIZE_PASS(DummyCGSCCPass, "DummyCGSCCPass", "DummyCGSCCPass", false,
                 false)

lib/Analysis/LoopPass.cpp

 // and transformation passes are derived from LoopPass. LPPassManager is
 // responsible for managing LoopPasses.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/LoopAnalysisManager.h"
 #include "llvm/IR/Dominators.h"
+#include "llvm/IR/GitCommitModule.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/OptBisect.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
public:
   }
 
   StringRef getPassName() const override { return "Print Loop IR"; }
 };
 
 char PrintLoopPassWrapper::ID = 0;
 }
 
+static Module &getModule(Loop *L) { return *L->getHeader()->getModule(); }
+#define RUN_ON(Loop, L) runOn##Loop(Loop *L, LPPassManager &)
+GIT_COMMIT_MODULE_PASS_WRAPPER_INTERNAL(Loop, getModule, RUN_ON)
+#undef RUN_ON
+
 //===----------------------------------------------------------------------===//
 // LPPassManager
 //
 
 char LPPassManager::ID = 0;
 
 LPPassManager::LPPassManager()
   : FunctionPass(ID), PMDataManager() {

 //===----------------------------------------------------------------------===//
 // LoopPass
 
 Pass *LoopPass::createPrinterPass(raw_ostream &O,
                                   const std::string &Banner) const {
   return new PrintLoopPassWrapper(O, Banner);
 }
 
+Pass *LoopPass::createGitCommitModulePass(const std::string &GitRepo,
+                                          const std::string &Message) const {
+  return new GitCommitLoopPassWrapper(GitRepo, Message);
+}
+
 // Check if this pass is suitable for the current LPPassManager, if
 // available. This pass P is not suitable for a LPPassManager if P
 // is not preserving higher level analysis info used by other
 // LPPassManager passes. In such case, pop LPPassManager from the
 // stack. This will force assignPassManager() to create new
 // LPPassManger as expected.
 void LoopPass::preparePassManager(PMStack &PMS) {
 

lib/Analysis/RegionPass.cpp

 //===- RegionPass.cpp - Region Pass and Region Pass Manager ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements RegionPass and RGPassManager. All region optimization
 // and transformation passes are derived from RegionPass. RGPassManager is
 // responsible for managing RegionPasses.
 // Most of this code has been COPIED from LoopPass.cpp
 //
 //===----------------------------------------------------------------------===//
 #include "llvm/Analysis/RegionPass.h"
+#include "llvm/IR/GitCommitModule.h"
 #include "llvm/IR/OptBisect.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "regionpassmgr"
 

 }
 
 /// Get the printer pass
 Pass *RegionPass::createPrinterPass(raw_ostream &O,
                                   const std::string &Banner) const {
   return new PrintRegionPass(Banner, O);
 }
 
+static Module &getModule(Region *R) {
+  return *R->getEntry()->getParent()->getParent();
+}
+
+#define RUN_ON(Region, R) runOn##Region(Region *R, RGPassManager &)
+GIT_COMMIT_MODULE_PASS_WRAPPER_INTERNAL(Region, getModule, RUN_ON)
+#undef RUN_ON
+
+Pass *RegionPass::createGitCommitModulePass(const std::string &GitRepo,
+                                            const std::string &Message) const {
+  return new GitCommitRegionPassWrapper(GitRepo, Message);
+}
+
 bool RegionPass::skipRegion(Region &R) const {
   Function &F = *R.getEntry()->getParent();
   if (!F.getContext().getOptBisect().shouldRunPass(this, R))
     return true;
 
   if (F.hasFnAttribute(Attribute::OptimizeNone)) {
     // Report this only once per function.
     if (R.getEntry() == &F.getEntryBlock())
       DEBUG(dbgs() << "Skipping pass '" << getPassName()
             << "' on function " << F.getName() << "\n");
     return true;
   }
   return false;
 }

lib/IR/CMakeLists.txt

add_llvm_library(LLVMCore
   DebugInfo.cpp
   DebugInfoMetadata.cpp
   DebugLoc.cpp
   DiagnosticHandler.cpp
   DiagnosticInfo.cpp
   DiagnosticPrinter.cpp
   Dominators.cpp
   Function.cpp
+  GitCommitModule.cpp
   GVMaterializer.cpp
   Globals.cpp
   IRBuilder.cpp
   IRPrintingPasses.cpp
   InlineAsm.cpp
   Instruction.cpp
   Instructions.cpp
   IntrinsicInst.cpp

lib/IR/GitCommitModule.cpp

+//===---- GitCommitModule.cpp ------ Write and Commit Module into Git -----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// GitCommitModulePass implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/GitCommitModule.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Program.h"
+#include "llvm/Support/raw_ostream.h"
+#define DEBUG_TYPE "git-commit-module"
+using namespace llvm;
+
+GitCommitModulePass::GitCommitModulePass() {}
+GitCommitModulePass::GitCommitModulePass(const std::string &GitRepo,
+                                         const std::string &Message,
+                                         bool ShouldPreserveUseListOrder)
+    : GitRepo(GitRepo), Message(Message),
+      ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
+  if(!init())
+    report_fatal_error("Folder is not writeable?");
+}
+
+#ifndef NDEBUG
+void dumpCommand(std::string Prog, ArrayRef<const char *> Args) {
+  dbgs() << "(" << Prog << ")";
+  for(auto Arg : Args)
+    if (Arg)
+      dbgs() << " '" << Arg << "'";
+  dbgs() << "\n";
+}
+#endif
+
+template <typename... T> static bool git(T... Args) {
+  auto Git = sys::findProgramByName("git");
+  if (!Git) {
+    DEBUG(dbgs() << "Cannot find 'git' in PATH: " << Git.getError().message()
+                 << "\n");
+    return false;
+  }
+  const char *FullArgs[] = {"git", Args..., nullptr};
+  DEBUG(dumpCommand(*Git, FullArgs));
+  return (sys::ExecuteAndWait(*Git, FullArgs) == 0);
+}
+
+bool GitCommitModulePass::init() {
+  return git("init", "--quiet", GitRepo.c_str());
+}
+
+bool GitCommitModulePass::printModule(Module &M) {
+  SmallString<128> FileName(M.getName());
+  sys::path::replace_extension(FileName, "ll");
+
+  SmallString<128> AbsFileName(GitRepo);
+  sys::path::append(AbsFileName, FileName);
+  std::error_code EC;
+  raw_fd_ostream OS(AbsFileName, EC, sys::fs::F_Text);
+
+  if (EC)
+    return false;
+
+  if (llvm::isFunctionInPrintList("*"))
+    M.print(OS, nullptr, ShouldPreserveUseListOrder);
+  else {
+    for (const auto &F : M.functions())
+      if (llvm::isFunctionInPrintList(F.getName()))
+        F.print(OS);
+  }
+
+  return git("-C", GitRepo.c_str(), "add", FileName.c_str());
+}
+
+bool GitCommitModulePass::commit() {
+  return git("-C", GitRepo.c_str(), "commit", "--allow-empty", "--quiet", "-m",
+             Message.c_str());
+}
+
+PreservedAnalyses GitCommitModulePass::run(Module &M,
+                                           AnalysisManager<Module> &) {
+  if (!printModule(M))
+    report_fatal_error("File is not writeable?");
+  if (!commit())
+    report_fatal_error("Git repository is broken?");
+  return PreservedAnalyses::all();
+}

lib/IR/LegacyPassManager.cpp

 
 static cl::opt<bool> PrintBeforeAll("print-before-all",
                                     llvm::cl::desc("Print IR before each pass"),
                                     cl::init(false), cl::Hidden);
 static cl::opt<bool> PrintAfterAll("print-after-all",
                                    llvm::cl::desc("Print IR after each pass"),
                                    cl::init(false), cl::Hidden);
 
+static cl::opt<std::string>
+    GitRepo("git-repo", llvm::cl::desc("Path to Git repository to initialize"),
+            cl::init("passes"), cl::Hidden);
+static cl::opt<bool> GitCommitModuleAfterAll(
+    "git-commit-after-all",
+    llvm::cl::desc("Print and commit IR after each pass"), cl::init(false),
+    cl::Hidden);
+
 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"),
public:
   }
 
   /// createPrinterPass - Get a function printer pass.
   Pass *createPrinterPass(raw_ostream &O,
                           const std::string &Banner) const override {
     return createPrintFunctionPass(O, Banner);
   }
 
+  /// createGitCommitModulePass - Get a git-commit module pass.
+  Pass *createGitCommitModulePass(const std::string &GitRepo,
+                                  const std::string &Message) const override {
+    // Pass managers don't need to do git commit
+    return nullptr;
+  }
+
   // Prepare for running an on the fly pass, freeing memory if needed
   // from a previous run.
   void releaseMemoryOnTheFly();
 
   /// run - Execute all of the passes scheduled for execution.  Keep track of
   /// whether any of the passes modifies the module, and if so, return true.
   bool run(Function &F);
 
public:
   }
 
   /// createPrinterPass - Get a module printer pass.
   Pass *createPrinterPass(raw_ostream &O,
                           const std::string &Banner) const override {
     return createPrintModulePass(O, Banner);
   }
 
+  /// createGitCommitModulePass - Get a git-commit module pass.
+  Pass *createGitCommitModulePass(const std::string &GitRepo,
+                                  const std::string &Message) const override {
+    // Pass managers don't need to do git commit
+    return nullptr;
+  }
+
   /// run - Execute all of the passes scheduled for execution.  Keep track of
   /// whether any of the passes modifies the module, and if so, return true.
   bool runOnModule(Module &M);
 
   using llvm::Pass::doInitialization;
   using llvm::Pass::doFinalization;
 
   /// Pass Manager itself does not invalidate any analysis info.
public:
   }
 
   /// createPrinterPass - Get a module printer pass.
   Pass *createPrinterPass(raw_ostream &O,
                           const std::string &Banner) const override {
     return createPrintModulePass(O, Banner);
   }
 
+  /// createGitCommitModulePass - Get a git-commit module pass.
+  Pass *createGitCommitModulePass(const std::string &GitRepo,
+                                  const std::string &Message) const override {
+    // Pass managers don't need to do git commit
+    return nullptr;
+  }
+
   /// run - Execute all of the passes scheduled for execution.  Keep track of
   /// whether any of the passes modifies the module, and if so, return true.
   bool run(Module &M);
 
   using llvm::Pass::doInitialization;
   using llvm::Pass::doFinalization;
 
   /// Pass Manager itself does not invalidate any analysis info.
void PMTopLevelManager::schedulePass(Pass *P) {
   // Add the requested pass to the best available pass manager.
   P->assignPassManager(activeStack, getTopLevelPassManagerType());
 
   if (PI && !PI->isAnalysis() && ShouldPrintAfterPass(PI)) {
     Pass *PP = P->createPrinterPass(
         dbgs(), ("*** IR Dump After " + P->getPassName() + " ***").str());
     PP->assignPassManager(activeStack, getTopLevelPassManagerType());
   }
+
+  if (PI && !PI->isAnalysis() && GitCommitModuleAfterAll) {
+    // TODO Use the pass options as commit message instead
+    Pass *PP = P->createGitCommitModulePass(GitRepo, P->getPassName());
+    if (PP)
+      PP->assignPassManager(activeStack, getTopLevelPassManagerType());
+  }
 }
 
 /// Find the pass that implements Analysis AID. Search immutable
 /// passes and all pass managers. If desired pass is not found
 /// then return NULL.
 Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) {
   // For immutable passes we have a direct mapping from ID to pass, so check
   // that first.

lib/IR/Pass.cpp

 // optimally.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Pass.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/GitCommitModule.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassNameParser.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/OptBisect.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/PassInfo.h"
 #include "llvm/PassRegistry.h"
 #include "llvm/PassSupport.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 

 // Force out-of-line virtual method.
 ModulePass::~ModulePass() = default;
 
 Pass *ModulePass::createPrinterPass(raw_ostream &OS,
                                     const std::string &Banner) const {
   return createPrintModulePass(OS, Banner);
 }
 
+static Module &getModule(Module &M) { return M; }
+GIT_COMMIT_MODULE_PASS_WRAPPER(Module, getModule);
+
+Pass *ModulePass::createGitCommitModulePass(const std::string &GitRepo,
+                                            const std::string &Message) const {
+  return new GitCommitModulePassWrapper(GitRepo, Message);
+}
+
 PassManagerType ModulePass::getPotentialPassManagerType() const {
   return PMT_ModulePassManager;
 }
 
 bool ModulePass::skipModule(Module &M) const {
   return !M.getContext().getOptBisect().shouldRunPass(this, M);
 }
 

 // FunctionPass Implementation
 //
 
 Pass *FunctionPass::createPrinterPass(raw_ostream &OS,
                                       const std::string &Banner) const {
   return createPrintFunctionPass(OS, Banner);
 }
 
+static Module &getModule(Function &F) { return *F.getParent(); }
+GIT_COMMIT_MODULE_PASS_WRAPPER(Function, getModule);
+
+Pass *
+FunctionPass::createGitCommitModulePass(const std::string &GitRepo,
+                                        const std::string &Message) const {
+  return new GitCommitFunctionPassWrapper(GitRepo, Message);
+}
+
 PassManagerType FunctionPass::getPotentialPassManagerType() const {
   return PMT_FunctionPassManager;
 }
 
 bool FunctionPass::skipFunction(const Function &F) const {
   if (!F.getContext().getOptBisect().shouldRunPass(this, F))
     return true;
 

 // BasicBlockPass Implementation
 //
 
 Pass *BasicBlockPass::createPrinterPass(raw_ostream &OS,
                                         const std::string &Banner) const {
   return createPrintBasicBlockPass(OS, Banner);
 }
 
+static Module &getModule(BasicBlock &BB) {
+  return *BB.getParent()->getParent();
+}
+
+GIT_COMMIT_MODULE_PASS_WRAPPER(BasicBlock, getModule);
+
+Pass *
+BasicBlockPass::createGitCommitModulePass(const std::string &GitRepo,
+                                          const std::string &Message) const {
+  return new GitCommitBasicBlockPassWrapper(GitRepo, Message);
+}
+
 bool BasicBlockPass::doInitialization(Function &) {
   // By default, don't do anything.
   return false;
 }
 
 bool BasicBlockPass::doFinalization(Function &) {
   // By default, don't do anything.
   return false;