[PassManager] Add extension point to LTO pipeline to enable module optimization passes to run shortly before loop optimizations

[wsmoses]

Summary

This pass introduces an extension point to the LTO new pass manager pipeline to run module passes shortly before loop optimiaztion. This is necessary for transformation passes like Enzyme.

[wsmoses]

Move location of call before analysis

[aeubanks]

lg, but needs tests. grep for passes-ep-full-link-time-optimization-early to see similar tests

llvm/include/llvm/Passes/PassBuilder.h

public:
   /// Register a callback for a default optimizer pipeline extension point
   ///
   /// This extension point allows adding optimizations at the start of the full
   /// LTO pipeline.
   void registerFullLinkTimeOptimizationEarlyEPCallback(
       const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
     FullLinkTimeOptimizationEarlyEPCallbacks.push_back(C);
   }
   
   /// Register a callback for a default optimizer pipeline extension point
   ///
+  /// This extension point allows adding optimizations at the module level before
+  /// any loop optimizations are run.
+  void registerFullLinkTimeOptimizatioBeforeLoopEPCallback(
+      const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
+    FullLinkTimeOptimizationBeforeLoopEPCallbacks.push_back(C);
+  }
+
+  /// Register a callback for a default optimizer pipeline extension point
+  ///
   /// This extension point allows adding optimizations at the end of the full
   /// LTO pipeline.
   void registerFullLinkTimeOptimizationLastEPCallback(
       const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
     FullLinkTimeOptimizationLastEPCallbacks.push_back(C);
   }
 
   /// Register a callback for parsing an AliasAnalysis Name to populate
public:
   void invokeVectorizerStartEPCallbacks(FunctionPassManager &FPM,
                                         OptimizationLevel Level);
   void invokeOptimizerEarlyEPCallbacks(ModulePassManager &MPM,
                                        OptimizationLevel Level);
   void invokeOptimizerLastEPCallbacks(ModulePassManager &MPM,
                                       OptimizationLevel Level);
   void invokeFullLinkTimeOptimizationEarlyEPCallbacks(ModulePassManager &MPM,
                                                       OptimizationLevel Level);
+  void invokeFullLinkTimeOptimizationBeforeLoopEPCallbacks(ModulePassManager &MPM,
+                                                      OptimizationLevel Level);
   void invokeFullLinkTimeOptimizationLastEPCallbacks(ModulePassManager &MPM,
                                                      OptimizationLevel Level);
   void invokePipelineStartEPCallbacks(ModulePassManager &MPM,
                                       OptimizationLevel Level);
   void invokePipelineEarlySimplificationEPCallbacks(ModulePassManager &MPM,
                                                     OptimizationLevel Level);
 
 private:
private:
   // Module callbacks
   SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
       OptimizerEarlyEPCallbacks;
   SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
       OptimizerLastEPCallbacks;
   SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
       FullLinkTimeOptimizationEarlyEPCallbacks;
   SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
+      FullLinkTimeOptimizationBeforeLoopEPCallbacks;
+  SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
       FullLinkTimeOptimizationLastEPCallbacks;
   SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
       PipelineStartEPCallbacks;
   SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
       PipelineEarlySimplificationEPCallbacks;
 
   SmallVector<std::function<void(ModuleAnalysisManager &)>, 2>
       ModuleAnalysisRegistrationCallbacks;

llvm/lib/Passes/PassBuilderPipelines.cpp

void PassBuilder::invokeOptimizerLastEPCallbacks(ModulePassManager &MPM,
   for (auto &C : OptimizerLastEPCallbacks)
     C(MPM, Level);
 }
 void PassBuilder::invokeFullLinkTimeOptimizationEarlyEPCallbacks(
     ModulePassManager &MPM, OptimizationLevel Level) {
   for (auto &C : FullLinkTimeOptimizationEarlyEPCallbacks)
     C(MPM, Level);
 }
+void PassBuilder::invokeFullLinkTimeOptimizationBeforeLoopEPCallbacks(
+    ModulePassManager &MPM, OptimizationLevel Level) {
+  for (auto &C : FullLinkTimeOptimizationBeforeLoopEPCallbacks)
+    C(MPM, Level);
+}
 void PassBuilder::invokeFullLinkTimeOptimizationLastEPCallbacks(
     ModulePassManager &MPM, OptimizationLevel Level) {
   for (auto &C : FullLinkTimeOptimizationLastEPCallbacks)
     C(MPM, Level);
 }
 void PassBuilder::invokePipelineStartEPCallbacks(ModulePassManager &MPM,
                                                  OptimizationLevel Level) {
   for (auto &C : PipelineStartEPCallbacks)
PassBuilder::buildLTODefaultPipeline(OptimizationLevel Level,
 
   // Run a few AA driver optimizations here and now to cleanup the code.
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM),
                                                 PTO.EagerlyInvalidateAnalyses));
 
   MPM.addPass(
       createModuleToPostOrderCGSCCPassAdaptor(PostOrderFunctionAttrsPass()));
 
+  invokeFullLinkTimeOptimizationBeforeLoopEPCallbacks(MPM, Level);
+
   // Require the GlobalsAA analysis for the module so we can query it within
   // MainFPM.
   MPM.addPass(RequireAnalysisPass<GlobalsAA, Module>());
+
   // Invalidate AAManager so it can be recreated and pick up the newly available
   // GlobalsAA.
   MPM.addPass(
       createModuleToFunctionPassAdaptor(InvalidateAnalysisPass<AAManager>()));
 
   FunctionPassManager MainFPM;
   MainFPM.addPass(createFunctionToLoopPassAdaptor(
       LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,