Skip to content

Commit f87a740

Browse files
author
git apple-llvm automerger
committed
Merge commit 'df8956442fed' from llvm.org/main into next
2 parents bc39303 + df89564 commit f87a740

18 files changed

+42
-200
lines changed

‎llvm/include/llvm/Analysis/LoopAnalysisManager.h‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,6 @@ namespace llvm {
3636

3737
class AAResults;
3838
class AssumptionCache;
39-
class BlockFrequencyInfo;
4039
class DominatorTree;
4140
class Function;
4241
class Loop;
@@ -58,7 +57,6 @@ struct LoopStandardAnalysisResults {
5857
ScalarEvolution &SE;
5958
TargetLibraryInfo &TLI;
6059
TargetTransformInfo &TTI;
61-
BlockFrequencyInfo *BFI;
6260
MemorySSA *MSSA;
6361
};
6462

‎llvm/include/llvm/Transforms/Scalar/LoopPassManager.h‎

Lines changed: 5 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -404,10 +404,8 @@ class FunctionToLoopPassAdaptor
404404

405405
explicit FunctionToLoopPassAdaptor(std::unique_ptr<PassConceptT> Pass,
406406
bool UseMemorySSA = false,
407-
bool UseBlockFrequencyInfo = false,
408407
bool LoopNestMode = false)
409408
: Pass(std::move(Pass)), UseMemorySSA(UseMemorySSA),
410-
UseBlockFrequencyInfo(UseBlockFrequencyInfo),
411409
LoopNestMode(LoopNestMode) {
412410
LoopCanonicalizationFPM.addPass(LoopSimplifyPass());
413411
LoopCanonicalizationFPM.addPass(LCSSAPass());
@@ -429,7 +427,6 @@ class FunctionToLoopPassAdaptor
429427
FunctionPassManager LoopCanonicalizationFPM;
430428

431429
bool UseMemorySSA = false;
432-
bool UseBlockFrequencyInfo = false;
433430
const bool LoopNestMode;
434431
};
435432

@@ -442,8 +439,7 @@ class FunctionToLoopPassAdaptor
442439
/// \c LoopPassManager and the returned adaptor will be in loop-nest mode.
443440
template <typename LoopPassT>
444441
inline FunctionToLoopPassAdaptor
445-
createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA = false,
446-
bool UseBlockFrequencyInfo = false) {
442+
createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA = false) {
447443
if constexpr (is_detected<HasRunOnLoopT, LoopPassT>::value) {
448444
using PassModelT =
449445
detail::PassModel<Loop, LoopPassT, LoopAnalysisManager,
@@ -453,7 +449,7 @@ createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA = false,
453449
return FunctionToLoopPassAdaptor(
454450
std::unique_ptr<FunctionToLoopPassAdaptor::PassConceptT>(
455451
new PassModelT(std::forward<LoopPassT>(Pass))),
456-
UseMemorySSA, UseBlockFrequencyInfo, false);
452+
UseMemorySSA, false);
457453
} else {
458454
LoopPassManager LPM;
459455
LPM.addPass(std::forward<LoopPassT>(Pass));
@@ -465,7 +461,7 @@ createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA = false,
465461
return FunctionToLoopPassAdaptor(
466462
std::unique_ptr<FunctionToLoopPassAdaptor::PassConceptT>(
467463
new PassModelT(std::move(LPM))),
468-
UseMemorySSA, UseBlockFrequencyInfo, true);
464+
UseMemorySSA, true);
469465
}
470466
}
471467

@@ -474,8 +470,7 @@ createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA = false,
474470
template <>
475471
inline FunctionToLoopPassAdaptor
476472
createFunctionToLoopPassAdaptor<LoopPassManager>(LoopPassManager &&LPM,
477-
bool UseMemorySSA,
478-
bool UseBlockFrequencyInfo) {
473+
bool UseMemorySSA) {
479474
// Check if LPM contains any loop pass and if it does not, returns an adaptor
480475
// in loop-nest mode.
481476
using PassModelT =
@@ -487,7 +482,7 @@ createFunctionToLoopPassAdaptor<LoopPassManager>(LoopPassManager &&LPM,
487482
return FunctionToLoopPassAdaptor(
488483
std::unique_ptr<FunctionToLoopPassAdaptor::PassConceptT>(
489484
new PassModelT(std::move(LPM))),
490-
UseMemorySSA, UseBlockFrequencyInfo, LoopNestMode);
485+
UseMemorySSA, LoopNestMode);
491486
}
492487

493488
/// Pass for printing a loop's contents as textual IR.

‎llvm/lib/Passes/PassBuilder.cpp‎

Lines changed: 14 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -2029,23 +2029,22 @@ Error PassBuilder::parseModulePass(ModulePassManager &MPM,
20292029
#define LOOPNEST_PASS(NAME, CREATE_PASS) \
20302030
if (Name == NAME) { \
20312031
MPM.addPass(createModuleToFunctionPassAdaptor( \
2032-
createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
2032+
createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
20332033
return Error::success(); \
20342034
}
20352035
#define LOOP_PASS(NAME, CREATE_PASS) \
20362036
if (Name == NAME) { \
20372037
MPM.addPass(createModuleToFunctionPassAdaptor( \
2038-
createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
2038+
createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
20392039
return Error::success(); \
20402040
}
20412041
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
20422042
if (checkParametrizedPassName(Name, NAME)) { \
20432043
auto Params = parsePassParameters(PARSER, Name, NAME); \
20442044
if (!Params) \
20452045
return Params.takeError(); \
2046-
MPM.addPass( \
2047-
createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
2048-
CREATE_PASS(Params.get()), false, false))); \
2046+
MPM.addPass(createModuleToFunctionPassAdaptor( \
2047+
createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false))); \
20492048
return Error::success(); \
20502049
}
20512050
#include "PassRegistry.def"
@@ -2144,23 +2143,22 @@ Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
21442143
#define LOOPNEST_PASS(NAME, CREATE_PASS) \
21452144
if (Name == NAME) { \
21462145
CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2147-
createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
2146+
createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
21482147
return Error::success(); \
21492148
}
21502149
#define LOOP_PASS(NAME, CREATE_PASS) \
21512150
if (Name == NAME) { \
21522151
CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2153-
createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
2152+
createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
21542153
return Error::success(); \
21552154
}
21562155
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
21572156
if (checkParametrizedPassName(Name, NAME)) { \
21582157
auto Params = parsePassParameters(PARSER, Name, NAME); \
21592158
if (!Params) \
21602159
return Params.takeError(); \
2161-
CGPM.addPass( \
2162-
createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
2163-
CREATE_PASS(Params.get()), false, false))); \
2160+
CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2161+
createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false))); \
21642162
return Error::success(); \
21652163
}
21662164
#include "PassRegistry.def"
@@ -2193,11 +2191,8 @@ Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
21932191
return Err;
21942192
// Add the nested pass manager with the appropriate adaptor.
21952193
bool UseMemorySSA = (Name == "loop-mssa");
2196-
bool UseBFI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
2197-
return Pipeline.Name.contains("simple-loop-unswitch");
2198-
});
2199-
FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA,
2200-
UseBFI));
2194+
FPM.addPass(
2195+
createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA));
22012196
return Error::success();
22022197
}
22032198
if (Name == "machine-function") {
@@ -2250,21 +2245,21 @@ Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
22502245
// The risk is that it may become obsolete if we're not careful.
22512246
#define LOOPNEST_PASS(NAME, CREATE_PASS) \
22522247
if (Name == NAME) { \
2253-
FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
2248+
FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false)); \
22542249
return Error::success(); \
22552250
}
22562251
#define LOOP_PASS(NAME, CREATE_PASS) \
22572252
if (Name == NAME) { \
2258-
FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
2253+
FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false)); \
22592254
return Error::success(); \
22602255
}
22612256
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
22622257
if (checkParametrizedPassName(Name, NAME)) { \
22632258
auto Params = parsePassParameters(PARSER, Name, NAME); \
22642259
if (!Params) \
22652260
return Params.takeError(); \
2266-
FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
2267-
false, false)); \
2261+
FPM.addPass( \
2262+
createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false)); \
22682263
return Error::success(); \
22692264
}
22702265
#include "PassRegistry.def"

‎llvm/lib/Passes/PassBuilderPipelines.cpp‎

Lines changed: 14 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -527,16 +527,14 @@ PassBuilder::buildO1FunctionSimplificationPipeline(OptimizationLevel Level,
527527
invokeLoopOptimizerEndEPCallbacks(LPM2, Level);
528528

529529
FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM1),
530-
/*UseMemorySSA=*/true,
531-
/*UseBlockFrequencyInfo=*/true));
530+
/*UseMemorySSA=*/true));
532531
FPM.addPass(
533532
SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(true)));
534533
FPM.addPass(InstCombinePass());
535534
// The loop passes in LPM2 (LoopFullUnrollPass) do not preserve MemorySSA.
536535
// *All* loop passes must preserve it, in order to be able to use it.
537536
FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM2),
538-
/*UseMemorySSA=*/false,
539-
/*UseBlockFrequencyInfo=*/false));
537+
/*UseMemorySSA=*/false));
540538

541539
// Delete small array after loop unroll.
542540
FPM.addPass(SROAPass(SROAOptions::ModifyCFG));
@@ -718,17 +716,15 @@ PassBuilder::buildFunctionSimplificationPipeline(OptimizationLevel Level,
718716
invokeLoopOptimizerEndEPCallbacks(LPM2, Level);
719717

720718
FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM1),
721-
/*UseMemorySSA=*/true,
722-
/*UseBlockFrequencyInfo=*/true));
719+
/*UseMemorySSA=*/true));
723720
FPM.addPass(
724721
SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(true)));
725722
FPM.addPass(InstCombinePass());
726723
// The loop passes in LPM2 (LoopIdiomRecognizePass, IndVarSimplifyPass,
727724
// LoopDeletionPass and LoopFullUnrollPass) do not preserve MemorySSA.
728725
// *All* loop passes must preserve it, in order to be able to use it.
729726
FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM2),
730-
/*UseMemorySSA=*/false,
731-
/*UseBlockFrequencyInfo=*/false));
727+
/*UseMemorySSA=*/false));
732728

733729
// Delete small array after loop unroll.
734730
FPM.addPass(SROAPass(SROAOptions::ModifyCFG));
@@ -784,7 +780,7 @@ PassBuilder::buildFunctionSimplificationPipeline(OptimizationLevel Level,
784780
FPM.addPass(createFunctionToLoopPassAdaptor(
785781
LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
786782
/*AllowSpeculation=*/true),
787-
/*UseMemorySSA=*/true, /*UseBlockFrequencyInfo=*/false));
783+
/*UseMemorySSA=*/true));
788784

789785
FPM.addPass(CoroElidePass());
790786

@@ -853,8 +849,7 @@ void PassBuilder::addPostPGOLoopRotation(ModulePassManager &MPM,
853849
createFunctionToLoopPassAdaptor(
854850
LoopRotatePass(EnableLoopHeaderDuplication ||
855851
Level != OptimizationLevel::Oz),
856-
/*UseMemorySSA=*/false,
857-
/*UseBlockFrequencyInfo=*/false),
852+
/*UseMemorySSA=*/false),
858853
PTO.EagerlyInvalidateAnalyses));
859854
}
860855
}
@@ -1369,8 +1364,7 @@ void PassBuilder::addVectorPasses(OptimizationLevel Level,
13691364
LPM.addPass(SimpleLoopUnswitchPass(/* NonTrivial */ Level ==
13701365
OptimizationLevel::O3));
13711366
ExtraPasses.addPass(
1372-
createFunctionToLoopPassAdaptor(std::move(LPM), /*UseMemorySSA=*/true,
1373-
/*UseBlockFrequencyInfo=*/true));
1367+
createFunctionToLoopPassAdaptor(std::move(LPM), /*UseMemorySSA=*/true));
13741368
ExtraPasses.addPass(
13751369
SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(true)));
13761370
ExtraPasses.addPass(InstCombinePass());
@@ -1449,7 +1443,7 @@ void PassBuilder::addVectorPasses(OptimizationLevel Level,
14491443
FPM.addPass(createFunctionToLoopPassAdaptor(
14501444
LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
14511445
/*AllowSpeculation=*/true),
1452-
/*UseMemorySSA=*/true, /*UseBlockFrequencyInfo=*/false));
1446+
/*UseMemorySSA=*/true));
14531447

14541448
// Now that we've vectorized and unrolled loops, we may have more refined
14551449
// alignment information, try to re-derive it here.
@@ -1531,7 +1525,7 @@ PassBuilder::buildModuleOptimizationPipeline(OptimizationLevel Level,
15311525
OptimizePM.addPass(createFunctionToLoopPassAdaptor(
15321526
LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
15331527
/*AllowSpeculation=*/true),
1534-
/*USeMemorySSA=*/true, /*UseBlockFrequencyInfo=*/false));
1528+
/*USeMemorySSA=*/true));
15351529
}
15361530

15371531
OptimizePM.addPass(Float2IntPass());
@@ -1571,8 +1565,8 @@ PassBuilder::buildModuleOptimizationPipeline(OptimizationLevel Level,
15711565
if (PTO.LoopInterchange)
15721566
LPM.addPass(LoopInterchangePass());
15731567

1574-
OptimizePM.addPass(createFunctionToLoopPassAdaptor(
1575-
std::move(LPM), /*UseMemorySSA=*/false, /*UseBlockFrequencyInfo=*/false));
1568+
OptimizePM.addPass(
1569+
createFunctionToLoopPassAdaptor(std::move(LPM), /*UseMemorySSA=*/false));
15761570

15771571
// FIXME: This may not be the right place in the pipeline.
15781572
// We need to have the data to support the right place.
@@ -2169,7 +2163,7 @@ PassBuilder::buildLTODefaultPipeline(OptimizationLevel Level,
21692163
MainFPM.addPass(createFunctionToLoopPassAdaptor(
21702164
LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
21712165
/*AllowSpeculation=*/true),
2172-
/*USeMemorySSA=*/true, /*UseBlockFrequencyInfo=*/false));
2166+
/*USeMemorySSA=*/true));
21732167

21742168
if (RunNewGVN)
21752169
MainFPM.addPass(NewGVNPass());
@@ -2199,8 +2193,8 @@ PassBuilder::buildLTODefaultPipeline(OptimizationLevel Level,
21992193
PTO.ForgetAllSCEVInLoopUnroll));
22002194
// The loop passes in LPM (LoopFullUnrollPass) do not preserve MemorySSA.
22012195
// *All* loop passes must preserve it, in order to be able to use it.
2202-
MainFPM.addPass(createFunctionToLoopPassAdaptor(
2203-
std::move(LPM), /*UseMemorySSA=*/false, /*UseBlockFrequencyInfo=*/true));
2196+
MainFPM.addPass(
2197+
createFunctionToLoopPassAdaptor(std::move(LPM), /*UseMemorySSA=*/false));
22042198

22052199
MainFPM.addPass(LoopDistributePass());
22062200

‎llvm/lib/Transforms/Scalar/LoopPassManager.cpp‎

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,6 @@
88

99
#include "llvm/Transforms/Scalar/LoopPassManager.h"
1010
#include "llvm/Analysis/AssumptionCache.h"
11-
#include "llvm/Analysis/BlockFrequencyInfo.h"
1211
#include "llvm/Analysis/MemorySSA.h"
1312
#include "llvm/Analysis/ScalarEvolution.h"
1413
#include "llvm/Analysis/TargetLibraryInfo.h"
@@ -217,17 +216,13 @@ PreservedAnalyses FunctionToLoopPassAdaptor::run(Function &F,
217216
// Get the analysis results needed by loop passes.
218217
MemorySSA *MSSA =
219218
UseMemorySSA ? (&AM.getResult<MemorySSAAnalysis>(F).getMSSA()) : nullptr;
220-
BlockFrequencyInfo *BFI = UseBlockFrequencyInfo && F.hasProfileData()
221-
? (&AM.getResult<BlockFrequencyAnalysis>(F))
222-
: nullptr;
223219
LoopStandardAnalysisResults LAR = {AM.getResult<AAManager>(F),
224220
AM.getResult<AssumptionAnalysis>(F),
225221
AM.getResult<DominatorTreeAnalysis>(F),
226222
AM.getResult<LoopAnalysis>(F),
227223
AM.getResult<ScalarEvolutionAnalysis>(F),
228224
AM.getResult<TargetLibraryAnalysis>(F),
229225
AM.getResult<TargetIRAnalysis>(F),
230-
BFI,
231226
MSSA};
232227

233228
// Setup the loop analysis manager from its proxy. It is important that

0 commit comments

Comments
 (0)