!fixup move extra loop pass manager and adjust naming & comments

Author: fhahn

llvm/include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h

@@ -13,6 +13,7 @@
 #include "llvm/Analysis/LoopAnalysisManager.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
+#include "llvm/Transforms/Utils/ExtraPassManager.h"
 
 namespace llvm {
 
@@ -21,40 +22,6 @@ class Loop;
 class StringRef;
 class raw_ostream;
 
-struct ShouldRunExtraSimpleLoopUnswitch
-    : public AnalysisInfoMixin<ShouldRunExtraSimpleLoopUnswitch> {
-  static AnalysisKey Key;
-  struct Result {
-    bool invalidate(Loop &L, const PreservedAnalyses &PA,
-                    LoopAnalysisManager::Invalidator &) {
-      // Check whether the analysis has been explicitly invalidated. Otherwise,
-      // it remains preserved.
-      auto PAC = PA.getChecker<ShouldRunExtraSimpleLoopUnswitch>();
-      return !PAC.preservedWhenStateless();
-    }
-  };
-
-  Result run(Loop &L, LoopAnalysisManager &AM,
-             LoopStandardAnalysisResults &AR) {
-    return Result();
-  }
-
-  static bool isRequired() { return true; }
-};
-
-struct ExtraSimpleLoopUnswitchPassManager : public LoopPassManager {
-  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
-                        LoopStandardAnalysisResults &AR, LPMUpdater &U) {
-    auto PA = PreservedAnalyses::all();
-    if (AM.getCachedResult<ShouldRunExtraSimpleLoopUnswitch>(L))
-      PA.intersect(LoopPassManager::run(L, AM, AR, U));
-    PA.abandon<ShouldRunExtraSimpleLoopUnswitch>();
-    return PA;
-  }
-
-  static bool isRequired() { return true; }
-};
-
 /// This pass transforms loops that contain branches or switches on loop-
 /// invariant conditions to have multiple loops. For example, it turns the left
 /// into the right code:
@@ -113,6 +80,16 @@ class SimpleLoopUnswitchPass : public PassInfoMixin<SimpleLoopUnswitchPass> {
                      function_ref<StringRef(StringRef)> MapClassName2PassName);
 };
 
+/// A marker analysis to determine if SimpleLoopUnswitch should run again on a
+/// given loop.
+struct ShouldRunExtraSimpleLoopUnswitch
+    : public ShouldRunExtraPasses<ShouldRunExtraSimpleLoopUnswitch>,
+      public AnalysisInfoMixin<ShouldRunExtraSimpleLoopUnswitch> {
+  static AnalysisKey Key;
+
+  static bool isRequired() { return true; }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_SIMPLELOOPUNSWITCH_H

llvm/include/llvm/Transforms/Utils/ExtraPassManager.h

@@ -1,6 +1,7 @@
-//===- ExtraPassManager.h - Loop pass management -----------------*- C++
+//===- ExtraFunctionPassManager.h - Run Optimizations on Demand ---------*- C++
 //-*-===//
 //
+//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -17,6 +18,7 @@
 #define LLVM_TRANSFORMS_UTILS_EXTRAPASSMANAGER_H
 
 #include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
 
 namespace llvm {
 
@@ -32,17 +34,30 @@ template <typename MarkerTy> struct ShouldRunExtraPasses {
       auto PAC = PA.getChecker<MarkerTy>();
       return !PAC.preservedWhenStateless();
     }
+
+    bool invalidate(Loop &L, const PreservedAnalyses &PA,
+                    LoopAnalysisManager::Invalidator &) {
+      // Check whether the analysis has been explicitly invalidated. Otherwise,
+      // it remains preserved.
+      auto PAC = PA.getChecker<MarkerTy>();
+      return !PAC.preservedWhenStateless();
+    }
   };
 
   Result run(Function &F, FunctionAnalysisManager &FAM) { return Result(); }
+
+  Result run(Loop &L, LoopAnalysisManager &AM,
+             LoopStandardAnalysisResults &AR) {
+    return Result();
+  }
 };
 
 /// A pass manager to run a set of extra function passes if the
 /// ShouldRunExtraPasses marker analysis is present. This allows passes to
 /// request additional transformations on demand. An example is extra
 /// simplifications after loop-vectorization, if runtime checks have been added.
 template <typename MarkerTy>
-struct ExtraPassManager : public FunctionPassManager {
+struct ExtraFunctionPassManager : public FunctionPassManager {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
     auto PA = PreservedAnalyses::all();
     if (AM.getCachedResult<MarkerTy>(F))
@@ -51,6 +66,24 @@ struct ExtraPassManager : public FunctionPassManager {
     return PA;
   }
 };
+
+/// A pass manager to run a set of extra loop passes if the MarkerTy analysis is
+/// present. This allows passes to request additional transformations on demand.
+/// An example is doing additional runs of SimpleLoopUnswitch.
+template <typename MarkerTy>
+struct ExtraLoopPassManager : public LoopPassManager {
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U) {
+    auto PA = PreservedAnalyses::all();
+    if (AM.getCachedResult<MarkerTy>(L))
+      PA.intersect(LoopPassManager::run(L, AM, AR, U));
+    PA.abandon<MarkerTy>();
+    return PA;
+  }
+
+  static bool isRequired() { return true; }
+};
+
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_EXTRAPASSMANAGER_H

llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h

@@ -170,7 +170,7 @@ void reportVectorizationFailure(const StringRef DebugMsg,
     const StringRef OREMsg, const StringRef ORETag,
     OptimizationRemarkEmitter *ORE, Loop *TheLoop, Instruction *I = nullptr);
 
-/// A marker analyss to determine if extra passes should be run after loop
+/// A marker analysis to determine if extra passes should be run after loop
 /// vectorization.
 struct ShouldRunExtraVectorPasses
     : public ShouldRunExtraPasses<ShouldRunExtraVectorPasses>,

llvm/lib/Passes/PassBuilderPipelines.cpp

@@ -661,7 +661,7 @@ PassBuilder::buildFunctionSimplificationPipeline(OptimizationLevel Level,
   LPM2.addPass(IndVarSimplifyPass());
 
   {
-    ExtraSimpleLoopUnswitchPassManager ExtraPasses;
+    ExtraLoopPassManager<ShouldRunExtraSimpleLoopUnswitch> ExtraPasses;
     ExtraPasses.addPass(SimpleLoopUnswitchPass(/* NonTrivial */ Level ==
                                                OptimizationLevel::O3));
     LPM2.addPass(std::move(ExtraPasses));
@@ -1308,7 +1308,7 @@ void PassBuilder::addVectorPasses(OptimizationLevel Level,
   FPM.addPass(InstCombinePass());
 
   if (Level.getSpeedupLevel() > 1 && ExtraVectorizerPasses) {
-    ExtraPassManager<ShouldRunExtraVectorPasses> ExtraPasses;
+    ExtraFunctionPassManager<ShouldRunExtraVectorPasses> ExtraPasses;
     // At higher optimization levels, try to clean up any runtime overlap and
     // alignment checks inserted by the vectorizer. We want to track correlated
     // runtime checks for two inner loops in the same outer loop, fold any