[llvm] [Passes] Generalize ShouldRunExtraVectorPasses to allow re-use (NFCI). (PR #118323)
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Wed Dec 4 06:02:36 PST 2024
https://github.com/fhahn updated https://github.com/llvm/llvm-project/pull/118323
>From 62d3210fc58092b6fc929f5128c30ee6a26170f7 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Sun, 1 Dec 2024 12:56:39 +0000
Subject: [PATCH 1/5] [Passes] Generalize ShouldRunExtraVectorPasses to allow
re-use (NFCI).
Generalize ShouldRunExtraVectorPasses toj ShouldRunExtraPasses, to allow
re-use for other transformations. I intend to use this to let
LowerMatrixIntrinsicsPass request EarlyCSE if there are any matrix
constructs to lower. This should allow enabling LowerMatrixIntrinsics
without a noticable compile-time hit.
---
llvm/include/llvm/IR/PassManager.h | 32 +++++++++++++++++++
.../llvm/Transforms/Vectorize/LoopVectorize.h | 32 -------------------
llvm/lib/IR/PassManager.cpp | 2 ++
llvm/lib/Passes/PassBuilderPipelines.cpp | 4 +--
llvm/lib/Passes/PassRegistry.def | 4 +--
.../Transforms/Vectorize/LoopVectorize.cpp | 6 ++--
6 files changed, 40 insertions(+), 40 deletions(-)
diff --git a/llvm/include/llvm/IR/PassManager.h b/llvm/include/llvm/IR/PassManager.h
index 5dab9d0d0a7979..91730301bbd415 100644
--- a/llvm/include/llvm/IR/PassManager.h
+++ b/llvm/include/llvm/IR/PassManager.h
@@ -935,6 +935,38 @@ struct InvalidateAllAnalysesPass : PassInfoMixin<InvalidateAllAnalysesPass> {
}
};
+/// A marker analyss to determine if extra passes should be run on demand.
+/// Passes requesting extra transformations to run need to request and preserve
+/// this analysis.
+struct ShouldRunExtraPasses : public AnalysisInfoMixin<ShouldRunExtraPasses> {
+ static AnalysisKey Key;
+ struct Result {
+ bool invalidate(Function &F, const PreservedAnalyses &PA,
+ FunctionAnalysisManager::Invalidator &) {
+ // Check whether the analysis has been explicitly invalidated. Otherwise,
+ // it remains preserved.
+ auto PAC = PA.getChecker<ShouldRunExtraPasses>();
+ return !PAC.preservedWhenStateless();
+ }
+ };
+
+ Result run(Function &F, FunctionAnalysisManager &FAM) { 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.
+struct ExtraPassManager : public FunctionPassManager {
+ PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
+ auto PA = PreservedAnalyses::all();
+ if (AM.getCachedResult<ShouldRunExtraPasses>(F))
+ PA.intersect(FunctionPassManager::run(F, AM));
+ PA.abandon<ShouldRunExtraPasses>();
+ return PA;
+ }
+};
+
} // end namespace llvm
#endif // LLVM_IR_PASSMANAGER_H
diff --git a/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h b/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h
index 24b6354662955e..9256cf16c0157e 100644
--- a/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h
+++ b/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h
@@ -80,38 +80,6 @@ class TargetTransformInfo;
extern cl::opt<bool> EnableLoopInterleaving;
extern cl::opt<bool> EnableLoopVectorization;
-/// A marker to determine if extra passes after loop vectorization should be
-/// run.
-struct ShouldRunExtraVectorPasses
- : public AnalysisInfoMixin<ShouldRunExtraVectorPasses> {
- static AnalysisKey Key;
- struct Result {
- bool invalidate(Function &F, const PreservedAnalyses &PA,
- FunctionAnalysisManager::Invalidator &) {
- // Check whether the analysis has been explicitly invalidated. Otherwise,
- // it remains preserved.
- auto PAC = PA.getChecker<ShouldRunExtraVectorPasses>();
- return !PAC.preservedWhenStateless();
- }
- };
-
- Result run(Function &F, FunctionAnalysisManager &FAM) { return Result(); }
-};
-
-/// A pass manager to run a set of extra function simplification passes after
-/// vectorization, if requested. LoopVectorize caches the
-/// ShouldRunExtraVectorPasses analysis to request extra simplifications, if
-/// they could be beneficial.
-struct ExtraVectorPassManager : public FunctionPassManager {
- PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
- auto PA = PreservedAnalyses::all();
- if (AM.getCachedResult<ShouldRunExtraVectorPasses>(F))
- PA.intersect(FunctionPassManager::run(F, AM));
- PA.abandon<ShouldRunExtraVectorPasses>();
- return PA;
- }
-};
-
struct LoopVectorizeOptions {
/// If false, consider all loops for interleaving.
/// If true, only loops that explicitly request interleaving are considered.
diff --git a/llvm/lib/IR/PassManager.cpp b/llvm/lib/IR/PassManager.cpp
index bf8f7906d3368d..4990695108fc70 100644
--- a/llvm/lib/IR/PassManager.cpp
+++ b/llvm/lib/IR/PassManager.cpp
@@ -160,3 +160,5 @@ void llvm::printIRUnitNameForStackTrace<Function>(raw_ostream &OS,
AnalysisSetKey CFGAnalyses::SetKey;
AnalysisSetKey PreservedAnalyses::AllAnalysesKey;
+
+AnalysisKey ShouldRunExtraPasses::Key;
diff --git a/llvm/lib/Passes/PassBuilderPipelines.cpp b/llvm/lib/Passes/PassBuilderPipelines.cpp
index 5a7c327de95870..5a8c60adccee34 100644
--- a/llvm/lib/Passes/PassBuilderPipelines.cpp
+++ b/llvm/lib/Passes/PassBuilderPipelines.cpp
@@ -1306,8 +1306,8 @@ void PassBuilder::addVectorPasses(OptimizationLevel Level,
// Cleanup after the loop optimization passes.
FPM.addPass(InstCombinePass());
+ ExtraPassManager ExtraPasses;
if (Level.getSpeedupLevel() > 1 && ExtraVectorizerPasses) {
- ExtraVectorPassManager 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
@@ -1328,8 +1328,8 @@ void PassBuilder::addVectorPasses(OptimizationLevel Level,
ExtraPasses.addPass(
SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(true)));
ExtraPasses.addPass(InstCombinePass());
- FPM.addPass(std::move(ExtraPasses));
}
+ FPM.addPass(std::move(ExtraPasses));
// Now that we've formed fast to execute loop structures, we do further
// optimizations. These are run afterward as they might block doing complex
diff --git a/llvm/lib/Passes/PassRegistry.def b/llvm/lib/Passes/PassRegistry.def
index 772ec5fd10e633..65083a20f7027e 100644
--- a/llvm/lib/Passes/PassRegistry.def
+++ b/llvm/lib/Passes/PassRegistry.def
@@ -303,8 +303,8 @@ FUNCTION_ANALYSIS("regions", RegionInfoAnalysis())
FUNCTION_ANALYSIS("scalar-evolution", ScalarEvolutionAnalysis())
FUNCTION_ANALYSIS("should-not-run-function-passes",
ShouldNotRunFunctionPassesAnalysis())
-FUNCTION_ANALYSIS("should-run-extra-vector-passes",
- ShouldRunExtraVectorPasses())
+FUNCTION_ANALYSIS("should-run-extra-passes",
+ ShouldRunExtraPasses())
FUNCTION_ANALYSIS("ssp-layout", SSPLayoutAnalysis())
FUNCTION_ANALYSIS("stack-safety-local", StackSafetyAnalysis())
FUNCTION_ANALYSIS("target-ir",
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index 3c7c044a042719..4e2918cacdfebd 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -442,8 +442,6 @@ using SCEV2ValueTy = DenseMap<const SCEV *, Value *>;
namespace llvm {
-AnalysisKey ShouldRunExtraVectorPasses::Key;
-
/// InnerLoopVectorizer vectorizes loops which contain only one basic
/// block to a specified vectorization factor (VF).
/// This class performs the widening of scalars into vectors, or multiple
@@ -10477,8 +10475,8 @@ PreservedAnalyses LoopVectorizePass::run(Function &F,
// extra simplification passes should be run.
// TODO: MadeCFGChanges is not a prefect proxy. Extra passes should only
// be run if runtime checks have been added.
- AM.getResult<ShouldRunExtraVectorPasses>(F);
- PA.preserve<ShouldRunExtraVectorPasses>();
+ AM.getResult<ShouldRunExtraPasses>(F);
+ PA.preserve<ShouldRunExtraPasses>();
} else {
PA.preserveSet<CFGAnalyses>();
}
>From 171bcd0802704d264c8787096ac57325acedae85 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Tue, 3 Dec 2024 13:05:48 +0000
Subject: [PATCH 2/5] !fixup move to separate header
---
llvm/include/llvm/IR/PassManager.h | 32 -----------
.../llvm/Transforms/Utils/ExtraPassManager.h | 56 +++++++++++++++++++
.../llvm/Transforms/Vectorize/LoopVectorize.h | 8 +++
llvm/lib/IR/PassManager.cpp | 1 -
llvm/lib/Passes/PassBuilder.cpp | 1 +
llvm/lib/Passes/PassBuilderPipelines.cpp | 5 +-
llvm/lib/Passes/PassRegistry.def | 4 +-
.../Transforms/Vectorize/LoopVectorize.cpp | 7 ++-
8 files changed, 75 insertions(+), 39 deletions(-)
create mode 100644 llvm/include/llvm/Transforms/Utils/ExtraPassManager.h
diff --git a/llvm/include/llvm/IR/PassManager.h b/llvm/include/llvm/IR/PassManager.h
index 91730301bbd415..5dab9d0d0a7979 100644
--- a/llvm/include/llvm/IR/PassManager.h
+++ b/llvm/include/llvm/IR/PassManager.h
@@ -935,38 +935,6 @@ struct InvalidateAllAnalysesPass : PassInfoMixin<InvalidateAllAnalysesPass> {
}
};
-/// A marker analyss to determine if extra passes should be run on demand.
-/// Passes requesting extra transformations to run need to request and preserve
-/// this analysis.
-struct ShouldRunExtraPasses : public AnalysisInfoMixin<ShouldRunExtraPasses> {
- static AnalysisKey Key;
- struct Result {
- bool invalidate(Function &F, const PreservedAnalyses &PA,
- FunctionAnalysisManager::Invalidator &) {
- // Check whether the analysis has been explicitly invalidated. Otherwise,
- // it remains preserved.
- auto PAC = PA.getChecker<ShouldRunExtraPasses>();
- return !PAC.preservedWhenStateless();
- }
- };
-
- Result run(Function &F, FunctionAnalysisManager &FAM) { 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.
-struct ExtraPassManager : public FunctionPassManager {
- PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
- auto PA = PreservedAnalyses::all();
- if (AM.getCachedResult<ShouldRunExtraPasses>(F))
- PA.intersect(FunctionPassManager::run(F, AM));
- PA.abandon<ShouldRunExtraPasses>();
- return PA;
- }
-};
-
} // end namespace llvm
#endif // LLVM_IR_PASSMANAGER_H
diff --git a/llvm/include/llvm/Transforms/Utils/ExtraPassManager.h b/llvm/include/llvm/Transforms/Utils/ExtraPassManager.h
new file mode 100644
index 00000000000000..c09a0dfd7753ab
--- /dev/null
+++ b/llvm/include/llvm/Transforms/Utils/ExtraPassManager.h
@@ -0,0 +1,56 @@
+//===- ExtraPassManager.h - Loop pass management -----------------*- 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
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file provides a pass manager that only runs its passes if the
+/// provided marker analysis has been preserved, together with a class to
+/// define such a marker analysis.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_EXTRAPASSMANAGER_H
+#define LLVM_TRANSFORMS_UTILS_EXTRAPASSMANAGER_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+/// A marker analysis to determine if extra passes should be run on demand.
+/// Passes requesting extra transformations to run need to request and preserve
+/// this analysis.
+template <typename MarkerTy> struct ShouldRunExtraPasses {
+ struct Result {
+ bool invalidate(Function &F, const PreservedAnalyses &PA,
+ FunctionAnalysisManager::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(); }
+};
+
+/// 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 {
+ PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
+ auto PA = PreservedAnalyses::all();
+ if (AM.getCachedResult<MarkerTy>(F))
+ PA.intersect(FunctionPassManager::run(F, AM));
+ PA.abandon<MarkerTy>();
+ return PA;
+ }
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_EXTRAPASSMANAGER_H
diff --git a/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h b/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h
index 9256cf16c0157e..e086ad2ad4abf9 100644
--- a/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h
+++ b/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h
@@ -58,6 +58,7 @@
#include "llvm/IR/PassManager.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Transforms/Utils/ExtraPassManager.h"
#include <functional>
namespace llvm {
@@ -169,6 +170,13 @@ 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
+/// vectorization.
+struct ShouldRunExtraVectorPasses
+ : public ShouldRunExtraPasses<ShouldRunExtraVectorPasses>,
+ public AnalysisInfoMixin<ShouldRunExtraVectorPasses> {
+ static AnalysisKey Key;
+};
} // end namespace llvm
#endif // LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H
diff --git a/llvm/lib/IR/PassManager.cpp b/llvm/lib/IR/PassManager.cpp
index 4990695108fc70..f497b10af329f3 100644
--- a/llvm/lib/IR/PassManager.cpp
+++ b/llvm/lib/IR/PassManager.cpp
@@ -161,4 +161,3 @@ AnalysisSetKey CFGAnalyses::SetKey;
AnalysisSetKey PreservedAnalyses::AllAnalysesKey;
-AnalysisKey ShouldRunExtraPasses::Key;
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index cc9f59727c6040..77dea7d06d0900 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -311,6 +311,7 @@
#include "llvm/Transforms/Utils/DXILUpgrade.h"
#include "llvm/Transforms/Utils/Debugify.h"
#include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
+#include "llvm/Transforms/Utils/ExtraPassManager.h"
#include "llvm/Transforms/Utils/FixIrreducible.h"
#include "llvm/Transforms/Utils/HelloWorld.h"
#include "llvm/Transforms/Utils/IRNormalizer.h"
diff --git a/llvm/lib/Passes/PassBuilderPipelines.cpp b/llvm/lib/Passes/PassBuilderPipelines.cpp
index 5a8c60adccee34..19e120b5eb5896 100644
--- a/llvm/lib/Passes/PassBuilderPipelines.cpp
+++ b/llvm/lib/Passes/PassBuilderPipelines.cpp
@@ -134,6 +134,7 @@
#include "llvm/Transforms/Utils/CanonicalizeAliases.h"
#include "llvm/Transforms/Utils/CountVisits.h"
#include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
+#include "llvm/Transforms/Utils/ExtraPassManager.h"
#include "llvm/Transforms/Utils/InjectTLIMappings.h"
#include "llvm/Transforms/Utils/LibCallsShrinkWrap.h"
#include "llvm/Transforms/Utils/Mem2Reg.h"
@@ -1306,8 +1307,8 @@ void PassBuilder::addVectorPasses(OptimizationLevel Level,
// Cleanup after the loop optimization passes.
FPM.addPass(InstCombinePass());
- ExtraPassManager ExtraPasses;
if (Level.getSpeedupLevel() > 1 && ExtraVectorizerPasses) {
+ ExtraPassManager<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
@@ -1328,8 +1329,8 @@ void PassBuilder::addVectorPasses(OptimizationLevel Level,
ExtraPasses.addPass(
SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(true)));
ExtraPasses.addPass(InstCombinePass());
+ FPM.addPass(std::move(ExtraPasses));
}
- FPM.addPass(std::move(ExtraPasses));
// Now that we've formed fast to execute loop structures, we do further
// optimizations. These are run afterward as they might block doing complex
diff --git a/llvm/lib/Passes/PassRegistry.def b/llvm/lib/Passes/PassRegistry.def
index 65083a20f7027e..772ec5fd10e633 100644
--- a/llvm/lib/Passes/PassRegistry.def
+++ b/llvm/lib/Passes/PassRegistry.def
@@ -303,8 +303,8 @@ FUNCTION_ANALYSIS("regions", RegionInfoAnalysis())
FUNCTION_ANALYSIS("scalar-evolution", ScalarEvolutionAnalysis())
FUNCTION_ANALYSIS("should-not-run-function-passes",
ShouldNotRunFunctionPassesAnalysis())
-FUNCTION_ANALYSIS("should-run-extra-passes",
- ShouldRunExtraPasses())
+FUNCTION_ANALYSIS("should-run-extra-vector-passes",
+ ShouldRunExtraVectorPasses())
FUNCTION_ANALYSIS("ssp-layout", SSPLayoutAnalysis())
FUNCTION_ANALYSIS("stack-safety-local", StackSafetyAnalysis())
FUNCTION_ANALYSIS("target-ir",
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index 4e2918cacdfebd..585cbddbd1633a 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -134,6 +134,7 @@
#include "llvm/Support/NativeFormatting.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
+#include "llvm/Transforms/Utils/ExtraPassManager.h"
#include "llvm/Transforms/Utils/InjectTLIMappings.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Transforms/Utils/LoopSimplify.h"
@@ -442,6 +443,8 @@ using SCEV2ValueTy = DenseMap<const SCEV *, Value *>;
namespace llvm {
+AnalysisKey ShouldRunExtraVectorPasses::Key;
+
/// InnerLoopVectorizer vectorizes loops which contain only one basic
/// block to a specified vectorization factor (VF).
/// This class performs the widening of scalars into vectors, or multiple
@@ -10475,8 +10478,8 @@ PreservedAnalyses LoopVectorizePass::run(Function &F,
// extra simplification passes should be run.
// TODO: MadeCFGChanges is not a prefect proxy. Extra passes should only
// be run if runtime checks have been added.
- AM.getResult<ShouldRunExtraPasses>(F);
- PA.preserve<ShouldRunExtraPasses>();
+ AM.getResult<ShouldRunExtraVectorPasses>(F);
+ PA.preserve<ShouldRunExtraVectorPasses>();
} else {
PA.preserveSet<CFGAnalyses>();
}
>From a43ded17412697c113f89ee9f48dd712b9fe6633 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Tue, 3 Dec 2024 13:14:59 +0000
Subject: [PATCH 3/5] !fixup fix formatting
---
llvm/lib/IR/PassManager.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/llvm/lib/IR/PassManager.cpp b/llvm/lib/IR/PassManager.cpp
index f497b10af329f3..bf8f7906d3368d 100644
--- a/llvm/lib/IR/PassManager.cpp
+++ b/llvm/lib/IR/PassManager.cpp
@@ -160,4 +160,3 @@ void llvm::printIRUnitNameForStackTrace<Function>(raw_ostream &OS,
AnalysisSetKey CFGAnalyses::SetKey;
AnalysisSetKey PreservedAnalyses::AllAnalysesKey;
-
>From c7772d2264d78d3d3fd620f85bf77ef8d603eac4 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Wed, 4 Dec 2024 13:55:27 +0000
Subject: [PATCH 4/5] !fixup move extra loop pass manager and adjust naming &
comments
---
.../Transforms/Scalar/SimpleLoopUnswitch.h | 45 +++++--------------
.../llvm/Transforms/Utils/ExtraPassManager.h | 37 ++++++++++++++-
.../llvm/Transforms/Vectorize/LoopVectorize.h | 2 +-
llvm/lib/Passes/PassBuilderPipelines.cpp | 4 +-
4 files changed, 49 insertions(+), 39 deletions(-)
diff --git a/llvm/include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h b/llvm/include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h
index a40b0a2a9ab72f..550c56b5123e62 100644
--- a/llvm/include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h
+++ b/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
diff --git a/llvm/include/llvm/Transforms/Utils/ExtraPassManager.h b/llvm/include/llvm/Transforms/Utils/ExtraPassManager.h
index c09a0dfd7753ab..f2a69efa16268c 100644
--- a/llvm/include/llvm/Transforms/Utils/ExtraPassManager.h
+++ b/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,9 +34,22 @@ 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
@@ -42,7 +57,7 @@ template <typename MarkerTy> struct ShouldRunExtraPasses {
/// 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
diff --git a/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h b/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h
index e086ad2ad4abf9..02935d0943f766 100644
--- a/llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h
+++ b/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>,
diff --git a/llvm/lib/Passes/PassBuilderPipelines.cpp b/llvm/lib/Passes/PassBuilderPipelines.cpp
index 19e120b5eb5896..d737ea5ab070a9 100644
--- a/llvm/lib/Passes/PassBuilderPipelines.cpp
+++ b/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
>From 55205b279e947ca927d9a157aebae43496d3be61 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Wed, 4 Dec 2024 14:02:10 +0000
Subject: [PATCH 5/5] !fixup remove include
---
llvm/lib/Transforms/Vectorize/LoopVectorize.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index 585cbddbd1633a..3c7c044a042719 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -134,7 +134,6 @@
#include "llvm/Support/NativeFormatting.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
-#include "llvm/Transforms/Utils/ExtraPassManager.h"
#include "llvm/Transforms/Utils/InjectTLIMappings.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Transforms/Utils/LoopSimplify.h"
More information about the llvm-commits
mailing list