From 5e888483e9ad020085998f86baa8ca3c16db1641 Mon Sep 17 00:00:00 2001 From: Florian Hahn Date: Sun, 1 Dec 2024 12:56:39 +0000 Subject: [PATCH 1/6] [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 5dab9d0d0a797..91730301bbd41 100644 --- a/llvm/include/llvm/IR/PassManager.h +++ b/llvm/include/llvm/IR/PassManager.h @@ -935,6 +935,38 @@ struct InvalidateAllAnalysesPass : PassInfoMixin { } }; +/// 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 { + 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(); + 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(F)) + PA.intersect(FunctionPassManager::run(F, AM)); + PA.abandon(); + 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 24b6354662955..9256cf16c0157 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 EnableLoopInterleaving; extern cl::opt EnableLoopVectorization; -/// A marker to determine if extra passes after loop vectorization should be -/// run. -struct ShouldRunExtraVectorPasses - : public AnalysisInfoMixin { - 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(); - 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(F)) - PA.intersect(FunctionPassManager::run(F, AM)); - PA.abandon(); - 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 bf8f7906d3368..4990695108fc7 100644 --- a/llvm/lib/IR/PassManager.cpp +++ b/llvm/lib/IR/PassManager.cpp @@ -160,3 +160,5 @@ void llvm::printIRUnitNameForStackTrace(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 5a7c327de9587..5a8c60adccee3 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 772ec5fd10e63..65083a20f7027 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 3c7c044a04271..4e2918cacdfeb 100644 --- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -442,8 +442,6 @@ using SCEV2ValueTy = DenseMap; 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(F); - PA.preserve(); + AM.getResult(F); + PA.preserve(); } else { PA.preserveSet(); } From 7ca89e8f19eecf1cd3f4a10d58ff8d04590d4a9f Mon Sep 17 00:00:00 2001 From: Florian Hahn Date: Tue, 3 Dec 2024 13:05:48 +0000 Subject: [PATCH 2/6] !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 91730301bbd41..5dab9d0d0a797 100644 --- a/llvm/include/llvm/IR/PassManager.h +++ b/llvm/include/llvm/IR/PassManager.h @@ -935,38 +935,6 @@ struct InvalidateAllAnalysesPass : PassInfoMixin { } }; -/// 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 { - 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(); - 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(F)) - PA.intersect(FunctionPassManager::run(F, AM)); - PA.abandon(); - 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 0000000000000..c09a0dfd7753a --- /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 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(); + 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 +struct ExtraPassManager : public FunctionPassManager { + PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) { + auto PA = PreservedAnalyses::all(); + if (AM.getCachedResult(F)) + PA.intersect(FunctionPassManager::run(F, AM)); + PA.abandon(); + 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 9256cf16c0157..e086ad2ad4abf 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 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, + public AnalysisInfoMixin { + 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 4990695108fc7..f497b10af329f 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 cc9f59727c604..77dea7d06d090 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 5a8c60adccee3..19e120b5eb589 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 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 65083a20f7027..772ec5fd10e63 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 4e2918cacdfeb..585cbddbd1633 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; 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(F); - PA.preserve(); + AM.getResult(F); + PA.preserve(); } else { PA.preserveSet(); } From 26ec4591ffc4302c8c228b915a6fdc6ca14c2b40 Mon Sep 17 00:00:00 2001 From: Florian Hahn Date: Tue, 3 Dec 2024 13:14:59 +0000 Subject: [PATCH 3/6] !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 f497b10af329f..bf8f7906d3368 100644 --- a/llvm/lib/IR/PassManager.cpp +++ b/llvm/lib/IR/PassManager.cpp @@ -160,4 +160,3 @@ void llvm::printIRUnitNameForStackTrace(raw_ostream &OS, AnalysisSetKey CFGAnalyses::SetKey; AnalysisSetKey PreservedAnalyses::AllAnalysesKey; - From 4061b67e957b1f1a67e3077261b074b479c2fb82 Mon Sep 17 00:00:00 2001 From: Florian Hahn Date: Wed, 4 Dec 2024 13:55:27 +0000 Subject: [PATCH 4/6] !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 a40b0a2a9ab72..550c56b5123e6 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 { - 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(); - 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(L)) - PA.intersect(LoopPassManager::run(L, AM, AR, U)); - PA.abandon(); - 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 { function_ref MapClassName2PassName); }; +/// A marker analysis to determine if SimpleLoopUnswitch should run again on a +/// given loop. +struct ShouldRunExtraSimpleLoopUnswitch + : public ShouldRunExtraPasses, + public AnalysisInfoMixin { + 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 c09a0dfd7753a..f2a69efa16268 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 struct ShouldRunExtraPasses { auto PAC = PA.getChecker(); 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(); + 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 struct ShouldRunExtraPasses { /// request additional transformations on demand. An example is extra /// simplifications after loop-vectorization, if runtime checks have been added. template -struct ExtraPassManager : public FunctionPassManager { +struct ExtraFunctionPassManager : public FunctionPassManager { PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) { auto PA = PreservedAnalyses::all(); if (AM.getCachedResult(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 +struct ExtraLoopPassManager : public LoopPassManager { + PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM, + LoopStandardAnalysisResults &AR, LPMUpdater &U) { + auto PA = PreservedAnalyses::all(); + if (AM.getCachedResult(L)) + PA.intersect(LoopPassManager::run(L, AM, AR, U)); + PA.abandon(); + 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 e086ad2ad4abf..02935d0943f76 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, diff --git a/llvm/lib/Passes/PassBuilderPipelines.cpp b/llvm/lib/Passes/PassBuilderPipelines.cpp index 19e120b5eb589..d737ea5ab070a 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 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 ExtraPasses; + ExtraFunctionPassManager 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 c58ee07a767cd8e53d809b9e5f4e22b71f1a5551 Mon Sep 17 00:00:00 2001 From: Florian Hahn Date: Wed, 4 Dec 2024 14:02:10 +0000 Subject: [PATCH 5/6] !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 585cbddbd1633..3c7c044a04271 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" From ddc503753a401ab868bb8978c6f315ead59fa4dc Mon Sep 17 00:00:00 2001 From: Florian Hahn Date: Wed, 4 Dec 2024 14:47:36 +0000 Subject: [PATCH 6/6] !fixup clean up headers --- llvm/include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h | 2 -- llvm/include/llvm/Transforms/Utils/ExtraPassManager.h | 6 +----- 2 files changed, 1 insertion(+), 7 deletions(-) diff --git a/llvm/include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h b/llvm/include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h index 550c56b5123e6..0cc49e4755257 100644 --- a/llvm/include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h +++ b/llvm/include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h @@ -86,8 +86,6 @@ struct ShouldRunExtraSimpleLoopUnswitch : public ShouldRunExtraPasses, public AnalysisInfoMixin { static AnalysisKey Key; - - static bool isRequired() { return true; } }; } // end namespace llvm diff --git a/llvm/include/llvm/Transforms/Utils/ExtraPassManager.h b/llvm/include/llvm/Transforms/Utils/ExtraPassManager.h index f2a69efa16268..7ea50a5584dde 100644 --- a/llvm/include/llvm/Transforms/Utils/ExtraPassManager.h +++ b/llvm/include/llvm/Transforms/Utils/ExtraPassManager.h @@ -1,6 +1,4 @@ -//===- ExtraFunctionPassManager.h - Run Optimizations on Demand ---------*- 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. @@ -80,8 +78,6 @@ struct ExtraLoopPassManager : public LoopPassManager { PA.abandon(); return PA; } - - static bool isRequired() { return true; } }; } // namespace llvm