[NewPM][CodeGen][WIP] Add callback style CodeGen pass pipeline builder

llvm/include/llvm/Analysis/CGSCCPassManager.h

@@ -347,6 +347,8 @@ class ModuleToPostOrderCGSCCPassAdaptor
 
   static bool isRequired() { return true; }
 
+  void eraseIf(function_ref<bool(StringRef)> Pred) { Pass->eraseIf(Pred); }
+
 private:
   std::unique_ptr<PassConceptT> Pass;
 };

llvm/include/llvm/CodeGen/MachinePassManager.h

@@ -207,6 +207,8 @@ class FunctionToMachineFunctionPassAdaptor
 
   static bool isRequired() { return true; }
 
+  void eraseIf(function_ref<bool(StringRef)> Pred) { Pass->eraseIf(Pred); }
+
 private:
   std::unique_ptr<PassConceptT> Pass;
 };

llvm/include/llvm/IR/PassManager.h

@@ -218,6 +218,18 @@ class PassManager : public PassInfoMixin<
 
   static bool isRequired() { return true; }
 
+  /// Erase all passes that satisfy the predicate \p Pred.
+  /// For internal use only!
+  void eraseIf(function_ref<bool(StringRef)> Pred) {
+    for (auto I = Passes.begin(); I != Passes.end();) {
+      (*I)->eraseIf(Pred);
+      if (Pred((*I)->name()) && !(*I)->isRequired())
+        I = Passes.erase(I);
+      else
+        ++I;
+    }
+  }
+
 protected:
   using PassConceptT =
       detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>;
@@ -836,6 +848,8 @@ class ModuleToFunctionPassAdaptor
 
   static bool isRequired() { return true; }
 
+  void eraseIf(function_ref<bool(StringRef)> Pred) { Pass->eraseIf(Pred); }
+
 private:
   std::unique_ptr<PassConceptT> Pass;
   bool EagerlyInvalidate;

llvm/include/llvm/IR/PassManagerInternal.h

@@ -59,6 +59,8 @@ struct PassConcept {
   /// To opt-in, pass should implement `static bool isRequired()`. It's no-op
   /// to have `isRequired` always return false since that is the default.
   virtual bool isRequired() const = 0;
+
+  virtual void eraseIf(function_ref<bool(StringRef)> Pred) = 0;
 };
 
 /// A template wrapper used to implement the polymorphic API.
@@ -114,6 +116,24 @@ struct PassModel : PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...> {
 
   bool isRequired() const override { return passIsRequiredImpl<PassT>(); }
 
+  template <typename T>
+  using has_erase_if_t = decltype(std::declval<T &>().eraseIf(
+      std::declval<function_ref<bool(StringRef)>>()));
+
+  template <typename T>
+  std::enable_if_t<is_detected<has_erase_if_t, T>::value>
+  eraseIfImpl(function_ref<bool(StringRef)> Pred) {
+    Pass.eraseIf(Pred);
+  }
+
+  template <typename T>
+  std::enable_if_t<!is_detected<has_erase_if_t, T>::value>
+  eraseIfImpl(function_ref<bool(StringRef)>) {}
+
+  void eraseIf(function_ref<bool(StringRef)> Pred) override {
+    eraseIfImpl<PassT>(Pred);
+  }
+
   PassT Pass;
 };
 

llvm/include/llvm/Passes/MachinePassRegistry.def

@@ -189,6 +189,7 @@ DUMMY_MACHINE_MODULE_PASS("mir-strip-debug", StripDebugMachineModulePass)
 #ifndef DUMMY_MACHINE_FUNCTION_PASS
 #define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME)
 #endif
+DUMMY_MACHINE_FUNCTION_PASS("bb-path-cloning", BasicBlockPathCloningPass)
 DUMMY_MACHINE_FUNCTION_PASS("bbsections-prepare", BasicBlockSectionsPass)
 DUMMY_MACHINE_FUNCTION_PASS("bbsections-profile-reader", BasicBlockSectionsProfileReaderPass)
 DUMMY_MACHINE_FUNCTION_PASS("block-placement", MachineBlockPlacementPass)
@@ -208,6 +209,8 @@ DUMMY_MACHINE_FUNCTION_PASS("fixup-statepoint-caller-saved", FixupStatepointCall
 DUMMY_MACHINE_FUNCTION_PASS("fs-profile-loader", MIRProfileLoaderNewPass)
 DUMMY_MACHINE_FUNCTION_PASS("funclet-layout", FuncletLayoutPass)
 DUMMY_MACHINE_FUNCTION_PASS("gc-empty-basic-blocks", GCEmptyBasicBlocksPass)
+DUMMY_MACHINE_FUNCTION_PASS("gc-machine-code-insersion",
+                            GCMachineCodeInsertionPass)
 DUMMY_MACHINE_FUNCTION_PASS("implicit-null-checks", ImplicitNullChecksPass)
 DUMMY_MACHINE_FUNCTION_PASS("init-undef-pass", InitUndefPass)
 DUMMY_MACHINE_FUNCTION_PASS("instruction-select", InstructionSelectPass)
@@ -260,6 +263,8 @@ DUMMY_MACHINE_FUNCTION_PASS("stack-slot-coloring", StackSlotColoringPass)
 DUMMY_MACHINE_FUNCTION_PASS("stackmap-liveness", StackMapLivenessPass)
 DUMMY_MACHINE_FUNCTION_PASS("tailduplication", TailDuplicatePass)
 DUMMY_MACHINE_FUNCTION_PASS("unpack-mi-bundles", UnpackMachineBundlesPass)
+DUMMY_MACHINE_FUNCTION_PASS("unreachable-mbb-elimination",
+                            UnreachableMachineBlockElimPass)
 DUMMY_MACHINE_FUNCTION_PASS("virtregrewriter", VirtRegRewriterPass)
 DUMMY_MACHINE_FUNCTION_PASS("xray-instrumentation", XRayInstrumentationPass)
 #undef DUMMY_MACHINE_FUNCTION_PASS

llvm/include/llvm/Passes/PassBuilder.h

@@ -15,14 +15,17 @@
 #ifndef LLVM_PASSES_PASSBUILDER_H
 #define LLVM_PASSES_PASSBUILDER_H
 
+#include "llvm/ADT/StringSet.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/CodeGen/MachinePassManager.h"
 #include "llvm/CodeGen/RegAllocCommon.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Passes/OptimizationLevel.h"
+#include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/PGOOptions.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/CGPassBuilderOption.h"
 #include "llvm/Transforms/IPO/Inliner.h"
 #include "llvm/Transforms/IPO/ModuleInliner.h"
 #include "llvm/Transforms/Instrumentation.h"
@@ -35,6 +38,7 @@ class StringRef;
 class AAManager;
 class TargetMachine;
 class ModuleSummaryIndex;
+class MCContext;
 template <typename T> class IntrusiveRefCntPtr;
 namespace vfs {
 class FileSystem;
@@ -307,6 +311,22 @@ class PassBuilder {
   /// TargetMachine::registerDefaultAliasAnalyses().
   AAManager buildDefaultAAPipeline();
 
+  /// Build CodeGen pass pipeline.
+  ///
+  /// {{@
+  Expected<ModulePassManager>
+  buildDefaultCodeGenPipeline(raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
+                              CodeGenFileType FileType, MCContext &Ctx);
+  Error buildDefaultCodeGenPipeline(ModulePassManager &MPM,
+                                    raw_pwrite_stream &Out,
+                                    raw_pwrite_stream *DwoOut,
+                                    CodeGenFileType FileType, MCContext &Ctx);
+  Error addRegAllocPass(MachineFunctionPassManager &MFPM, StringRef Filter);
+  template <typename... PassTs> void disablePass() {
+    (DisabledPasses.insert(PassTs::name()), ...);
+  }
+  /// @}}
+
   /// Parse a textual pass pipeline description into a \c
   /// ModulePassManager.
   ///
@@ -519,6 +539,106 @@ class PassBuilder {
     FullLinkTimeOptimizationLastEPCallbacks.push_back(C);
   }
 
+  void registerGCLoweringEPCallback(
+      const std::function<void(FunctionPassManager &)> C) {
+    GCLoweringEPCallbacks.push_back(C);
+  }
+
+  void registerISelPrepareEPCallback(
+      const std::function<void(ModulePassManager &)> &C) {
+    ISelPrepareEPCallbacks.push_back(C);
+  }
+
+  void registerMachineSSAOptimizationEarlyEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    MachineSSAOptimizationEarlyEPCallbacks.push_back(C);
+  }
+
+  void registerILPOptsEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    ILPOptsEPCallbacks.push_back(C);
+  }
+
+  void registerMachineSSAOptimizationLastEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    MachineSSAOptimizationLastEPCallbacks.push_back(C);
+  }
+
+  void registerPreRegAllocEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    PreRegAllocEPCallbacks.push_back(C);
+  }
+
+  void registerPostRegAllocEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    PostRegAllocEPCallbacks.push_back(C);
+  }
+
+  void registerPreRegBankSelectEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    PreRegBankSelectEPCallbacks.push_back(C);
+  }
+
+  void registerPreGlobalInstructionSelectEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    PreGlobalInstructionSelectEPCallbacks.push_back(C);
+  }
+
+  void registerPostGlobalInstructionSelectEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    PostGlobalInstructionSelectEPCallbacks.push_back(C);
+  }
+
+  void registerMachineLateOptimizationEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    MachineLateOptimizationEPCallbacks.push_back(C);
+  }
+
+  void registerPreSched2EPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    PreSched2EPCallbacks.push_back(C);
+  }
+
+  void registerPostRewriteEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    PostRewriteEPCallbacks.push_back(C);
+  }
+
+  void registerPreEmitEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    PreEmitEPCallbacks.push_back(C);
+  }
+
+  void registerPostBBSectionsEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    PostBBSectionsEPCallbacks.push_back(C);
+  }
+
+  void registerMIEmitEPCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    MIEmitEPCallbacks.push_back(C);
+  }
+
+  void setAddInstSelectorCallback(
+      const std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+          &C) {
+    AddInstSelectorCallback = C;
+  }
+
   /// Register a callback for parsing an AliasAnalysis Name to populate
   /// the given AAManager \p AA
   void registerParseAACallback(
@@ -639,6 +759,39 @@ class PassBuilder {
                                       OptimizationLevel Level);
   void invokePipelineEarlySimplificationEPCallbacks(ModulePassManager &MPM,
                                                     OptimizationLevel Level);
+  void invokeGCLoweringEPCallbacks(FunctionPassManager &FPM);
+  void invokeISelPrepareEPCallbacks(ModulePassManager &MPM);
+  void
+  invokeMachineSSAOptimizationEarlyEPCallbacks(MachineFunctionPassManager &MFPM,
+                                               CodeGenOptLevel Level);
+  void
+  invokeMachineSSAOptimizationLastEPCallbacks(MachineFunctionPassManager &MFPM,
+                                              CodeGenOptLevel Level);
+  void invokePreRegAllocEPCallbacks(MachineFunctionPassManager &MFPM,
+                                    CodeGenOptLevel Level);
+  void invokePostRegAllocEPCallbacks(MachineFunctionPassManager &MFPM,
+                                     CodeGenOptLevel Level);
+  void invokePreRegBankSelectEPCallbacks(MachineFunctionPassManager &MFPM,
+                                         CodeGenOptLevel Level);
+  void
+  invokePreGlobalInstructionSelectEPCallbacks(MachineFunctionPassManager &MFPM,
+                                              CodeGenOptLevel Level);
+  void
+  invokePostGlobalInstructionSelectEPCallbacks(MachineFunctionPassManager &MFPM,
+                                               CodeGenOptLevel Level);
+  void invokeILPOptsEPCallbacks(MachineFunctionPassManager &MFPM,
+                                CodeGenOptLevel Level);
+  void
+  invokeMachineLateOptimizationEPCallbacks(MachineFunctionPassManager &MFPM,
+                                           CodeGenOptLevel Level);
+  void invokePreEmitEPCallbacks(MachineFunctionPassManager &MFPM,
+                                CodeGenOptLevel Level);
+  void invokePostBBSectionsEPCallbacks(MachineFunctionPassManager &MFPM,
+                                       CodeGenOptLevel Level);
+  void invokeMIEmitEPCallbacks(MachineFunctionPassManager &MFPM,
+                               CodeGenOptLevel Level);
+  void invokePreSched2EPCallbacks(MachineFunctionPassManager &MFPM,
+                                  CodeGenOptLevel Level);
 
   static bool checkParametrizedPassName(StringRef Name, StringRef PassName) {
     if (!Name.consume_front(PassName))
@@ -704,6 +857,19 @@ class PassBuilder {
   void addVectorPasses(OptimizationLevel Level, FunctionPassManager &FPM,
                        bool IsFullLTO);
 
+  Error addExceptionHandlingPasses(FunctionPassManager &FPM);
+
+  Error addInstructionSelectorPasses(MachineFunctionPassManager &MFPM,
+                                     const CGPassBuilderOption &Options);
+
+  void addMachineSSAOptimizationPasses(MachineFunctionPassManager &MFPM,
+                                       CodeGenOptLevel Level);
+
+  Error addRegisterAllocatorPasses(MachineFunctionPassManager &MFPM,
+                                   const CGPassBuilderOption &Options);
+
+  Error setStartStop(ModulePassManager &MPM);
+
   static std::optional<std::vector<PipelineElement>>
   parsePipelineText(StringRef Text);
 
@@ -766,6 +932,63 @@ class PassBuilder {
   SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
       PipelineEarlySimplificationEPCallbacks;
 
+  // CodeGen extension point callbacks
+  SmallVector<std::function<void(FunctionPassManager &)>, 2>
+      GCLoweringEPCallbacks;
+  SmallVector<std::function<void(ModulePassManager &)>, 2>
+      ISelPrepareEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      MachineSSAOptimizationEarlyEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      MachineSSAOptimizationLastEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      PreRegAllocEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      PostRegAllocEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      PreRegBankSelectEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      PreGlobalInstructionSelectEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      PostGlobalInstructionSelectEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      ILPOptsEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      MachineLateOptimizationEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      PreSched2EPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      PostRewriteEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      PreEmitEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      PostBBSectionsEPCallbacks;
+  SmallVector<
+      std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>, 2>
+      MIEmitEPCallbacks;
+
+  std::function<void(CGPassBuilderOption &)>
+      CodeGenPassPipelineTunningCallback = [](CGPassBuilderOption &) {};
+  std::function<void(MachineFunctionPassManager &, CodeGenOptLevel)>
+      AddInstSelectorCallback;
+  std::function<void(MachineFunctionPassManager &)> AddFastRegAllocCallback;
+  std::function<void(PassBuilder &, MachineFunctionPassManager &)>
+      AddOptimizedRegAllocCallback;
+  StringSet<> DisabledPasses;
+
   SmallVector<std::function<void(ModuleAnalysisManager &)>, 2>
       ModuleAnalysisRegistrationCallbacks;
   SmallVector<std::function<bool(StringRef, ModulePassManager &,

llvm/include/llvm/Target/CGPassBuilderOption.h

@@ -41,6 +41,9 @@ struct CGPassBuilderOption {
   bool PrintLSR = false;
   bool DisableMergeICmps = false;
   bool DisablePartialLibcallInlining = false;
+  bool DisableReplaceWithVecLib = false;
+  bool DisableLayoutFSProfileLoader = false;
+  bool DisablePrologEpilogInserterPass = false;
   bool DisableConstantHoisting = false;
   bool DisableSelectOptimize = true;
   bool DisableAtExitBasedGlobalDtorLowering = false;