Proof of Concept for a (Machine)ModulePass

[MatzeB]

Summary

Proof of concept how a (Machine)ModulePass in the codegen pipeline can look like.

This is meant as an illustration not for actual submission into the repository.

[MatzeB]

This patch was just for illustration purposes. Abandon it to remove it from my list of open reviews.

lib/CodeGen/TargetPassConfig.cpp

 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/CFLAndersAliasAnalysis.h"
 #include "llvm/Analysis/CFLSteensAliasAnalysis.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/Passes.h"
 #include "llvm/Analysis/ScopedNoAliasAA.h"
 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/RegAllocRegistry.h"
 #include "llvm/CodeGen/RegisterUsageInfo.h"
+#include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"

 static cl::opt<bool> PrintISelInput("print-isel-input", cl::Hidden,
     cl::desc("Print LLVM IR input to isel pass"));
 static cl::opt<bool> PrintGCInfo("print-gc", cl::Hidden,
     cl::desc("Dump garbage collector data"));
 static cl::opt<bool> VerifyMachineCode("verify-machineinstrs", cl::Hidden,
     cl::desc("Verify generated machine code"),
     cl::init(false),
     cl::ZeroOrMore);
+static cl::opt<bool> AddDummyMachineModulePass("dummy-machine-module-pass",
+                                               cl::Hidden);
 
 static cl::opt<std::string>
 PrintMachineInstrs("print-machineinstrs", cl::ValueOptional,
                    cl::desc("Print machine instrs"),
                    cl::value_desc("pass-name"), cl::init("option-unspecified"));
 
 // Temporary option to allow experimenting with MachineScheduler as a post-RA
 // scheduler. Targets can "properly" enable this with
addPass(createPrintFunctionPass(
         dbgs(), "\n\n*** Final LLVM Code input to ISel ***\n"));
 
   // All passes which modify the LLVM IR are now complete; run the verifier
   // to ensure that the IR is valid.
   if (!DisableVerify)
     addPass(createVerifierPass());
 }
 
+namespace {
+
+/// This pass is simply a demonstration that module passes work for CodeGen.
+/// It adds a new IR and corresponding machine function late in the codegen
+/// pipeline.
+class DummyMachineModulePass : public ModulePass {
+public:
+  static char ID;
+  DummyMachineModulePass() : ModulePass(ID) {}
+
+  bool runOnModule(Module &M) override {
+    errs() << "RunOnModule\n";
+
+    // Let's create an empty function to show the concept.
+    LLVMContext &C = M.getContext();
+    Function *F = dyn_cast<Function>(
+      M.getOrInsertFunction("AddedFunc", Type::getVoidTy(C), NULL));
+    assert(F != nullptr);
+
+    BasicBlock *EntryBB = BasicBlock::Create(C, "entry", F);
+    IRBuilder<> Builder(EntryBB);
+    Builder.CreateRetVoid();
+
+    MachineModuleInfo &MMI = getAnalysis<MachineModuleInfo>();
+    MachineFunction &MF = MMI.getMachineFunction(*F);
+    MachineBasicBlock *MBB = MF.CreateMachineBasicBlock();
+
+    MF.getProperties().set(
+      MachineFunctionProperties::Property::AllVRegsAllocated);
+
+    MF.insert(MF.begin(), MBB);
+
+    return true;
+  }
+
+  const char *getPassName() const override { return "DummyMachineModulePass"; }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.addRequired<MachineModuleInfo>();
+    AU.addPreserved<MachineModuleInfo>();
+
+    ModulePass::getAnalysisUsage(AU);
+  }
+};
+
+char DummyMachineModulePass::ID = 0;
+
+}
+
 /// Add the complete set of target-independent postISel code generator passes.
 ///
 /// This can be read as the standard order of major LLVM CodeGen stages. Stages
 /// with nontrivial configuration or multiple passes are broken out below in
 /// add%Stage routines.
 ///
 /// Any TargetPassConfig::addXX routine may be overriden by the Target. The
 /// addPre/Post methods with empty header implementations allow injecting
void TargetPassConfig::addMachinePasses() {
   }
 
   // Basic block placement.
   if (getOptLevel() != CodeGenOpt::None)
     addBlockPlacement();
 
   addPreEmitPass();
 
+  if (AddDummyMachineModulePass)
+    PM->add(new DummyMachineModulePass());
+
   if (TM->Options.EnableIPRA)
     // Collect register usage information and produce a register mask of
     // clobbered registers, to be used to optimize call sites.
     addPass(createRegUsageInfoCollector());
 
   addPass(&FuncletLayoutID, false);
 
   addPass(&StackMapLivenessID, false);