Author: Chengjun Date: 2025-05-07T16:30:42-07:00 New Revision: 81dd9f5f4b1d6d76d967c24924eb41b9eb1ad639
URL: https://github.com/llvm/llvm-project/commit/81dd9f5f4b1d6d76d967c24924eb41b9eb1ad639 DIFF: https://github.com/llvm/llvm-project/commit/81dd9f5f4b1d6d76d967c24924eb41b9eb1ad639.diff LOG: Revert "[AA] Move Target Specific AA before BasicAA (#125965)" This reverts commit 94d933676c34c9179bf55387d3f9b97e12fae94b. Added: Modified: llvm/include/llvm/Analysis/AliasAnalysis.h llvm/include/llvm/Target/TargetMachine.h llvm/lib/Analysis/AliasAnalysis.cpp llvm/lib/Passes/PassBuilderPipelines.cpp llvm/lib/Target/NVPTX/NVPTXAliasAnalysis.h llvm/lib/Target/NVPTX/NVPTXTargetMachine.cpp llvm/lib/Target/NVPTX/NVPTXTargetMachine.h Removed: llvm/test/Analysis/NVPTXAA/NVPTXAA_before_BasicAA.ll ################################################################################ diff --git a/llvm/include/llvm/Analysis/AliasAnalysis.h b/llvm/include/llvm/Analysis/AliasAnalysis.h index d23b81854c9ea..b3b44a50ca827 100644 --- a/llvm/include/llvm/Analysis/AliasAnalysis.h +++ b/llvm/include/llvm/Analysis/AliasAnalysis.h @@ -1013,18 +1013,6 @@ struct ExternalAAWrapperPass : ImmutablePass { explicit ExternalAAWrapperPass(CallbackT CB); - /// Returns whether this external AA should run before Basic AA. - /// - /// By default, external AA passes are run after Basic AA. If this returns - /// true, the external AA will be run before Basic AA during alias analysis. - /// - /// For some targets, we prefer to run the external AA early to improve - /// compile time as it has more target-specific information. This is - /// particularly useful when the external AA can provide more precise results - /// than Basic AA so that Basic AA does not need to spend time recomputing - /// them. - virtual bool runEarly() { return false; } - void getAnalysisUsage(AnalysisUsage &AU) const override { AU.setPreservesAll(); } diff --git a/llvm/include/llvm/Target/TargetMachine.h b/llvm/include/llvm/Target/TargetMachine.h index 906926729ed74..566e7dba6792b 100644 --- a/llvm/include/llvm/Target/TargetMachine.h +++ b/llvm/include/llvm/Target/TargetMachine.h @@ -396,11 +396,6 @@ class TargetMachine { // TODO: Populate all pass names by using <Target>PassRegistry.def. virtual void registerPassBuilderCallbacks(PassBuilder &) {} - /// Allow the target to register early alias analyses (AA before BasicAA) with - /// the AAManager for use with the new pass manager. Only affects the - /// "default" AAManager. - virtual void registerEarlyDefaultAliasAnalyses(AAManager &) {} - /// Allow the target to register alias analyses with the AAManager for use /// with the new pass manager. Only affects the "default" AAManager. virtual void registerDefaultAliasAnalyses(AAManager &) {} diff --git a/llvm/lib/Analysis/AliasAnalysis.cpp b/llvm/lib/Analysis/AliasAnalysis.cpp index 27bd179a58ede..f4946c30de9bc 100644 --- a/llvm/lib/Analysis/AliasAnalysis.cpp +++ b/llvm/lib/Analysis/AliasAnalysis.cpp @@ -739,49 +739,28 @@ bool AAResultsWrapperPass::runOnFunction(Function &F) { AAR.reset( new AAResults(getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F))); - // Add any target-specific alias analyses that should be run early. - auto *ExtWrapperPass = getAnalysisIfAvailable<ExternalAAWrapperPass>(); - if (ExtWrapperPass && ExtWrapperPass->runEarly() && ExtWrapperPass->CB) { - LLVM_DEBUG(dbgs() << "AAResults register Early ExternalAA: " - << ExtWrapperPass->getPassName() << "\n"); - ExtWrapperPass->CB(*this, F, *AAR); - } - // BasicAA is always available for function analyses. Also, we add it first // so that it can trump TBAA results when it proves MustAlias. // FIXME: TBAA should have an explicit mode to support this and then we // should reconsider the ordering here. - if (!DisableBasicAA) { - LLVM_DEBUG(dbgs() << "AAResults register BasicAA\n"); + if (!DisableBasicAA) AAR->addAAResult(getAnalysis<BasicAAWrapperPass>().getResult()); - } // Populate the results with the currently available AAs. - if (auto *WrapperPass = - getAnalysisIfAvailable<ScopedNoAliasAAWrapperPass>()) { - LLVM_DEBUG(dbgs() << "AAResults register ScopedNoAliasAA\n"); + if (auto *WrapperPass = getAnalysisIfAvailable<ScopedNoAliasAAWrapperPass>()) AAR->addAAResult(WrapperPass->getResult()); - } - if (auto *WrapperPass = getAnalysisIfAvailable<TypeBasedAAWrapperPass>()) { - LLVM_DEBUG(dbgs() << "AAResults register TypeBasedAA\n"); + if (auto *WrapperPass = getAnalysisIfAvailable<TypeBasedAAWrapperPass>()) AAR->addAAResult(WrapperPass->getResult()); - } - if (auto *WrapperPass = getAnalysisIfAvailable<GlobalsAAWrapperPass>()) { - LLVM_DEBUG(dbgs() << "AAResults register GlobalsAA\n"); + if (auto *WrapperPass = getAnalysisIfAvailable<GlobalsAAWrapperPass>()) AAR->addAAResult(WrapperPass->getResult()); - } - if (auto *WrapperPass = getAnalysisIfAvailable<SCEVAAWrapperPass>()) { - LLVM_DEBUG(dbgs() << "AAResults register SCEVAA\n"); + if (auto *WrapperPass = getAnalysisIfAvailable<SCEVAAWrapperPass>()) AAR->addAAResult(WrapperPass->getResult()); - } // If available, run an external AA providing callback over the results as // well. - if (ExtWrapperPass && !ExtWrapperPass->runEarly() && ExtWrapperPass->CB) { - LLVM_DEBUG(dbgs() << "AAResults register Late ExternalAA: " - << ExtWrapperPass->getPassName() << "\n"); - ExtWrapperPass->CB(*this, F, *AAR); - } + if (auto *WrapperPass = getAnalysisIfAvailable<ExternalAAWrapperPass>()) + if (WrapperPass->CB) + WrapperPass->CB(*this, F, *AAR); // Analyses don't mutate the IR, so return false. return false; diff --git a/llvm/lib/Passes/PassBuilderPipelines.cpp b/llvm/lib/Passes/PassBuilderPipelines.cpp index 5a85b308925a6..f172271be09ab 100644 --- a/llvm/lib/Passes/PassBuilderPipelines.cpp +++ b/llvm/lib/Passes/PassBuilderPipelines.cpp @@ -2320,10 +2320,6 @@ AAManager PassBuilder::buildDefaultAAPipeline() { // The order in which these are registered determines their priority when // being queried. - // Add any target-specific alias analyses that should be run early. - if (TM) - TM->registerEarlyDefaultAliasAnalyses(AA); - // First we register the basic alias analysis that provides the majority of // per-function local AA logic. This is a stateless, on-demand local set of // AA techniques. diff --git a/llvm/lib/Target/NVPTX/NVPTXAliasAnalysis.h b/llvm/lib/Target/NVPTX/NVPTXAliasAnalysis.h index 430fcd741c1b6..a82c3aaa72423 100644 --- a/llvm/lib/Target/NVPTX/NVPTXAliasAnalysis.h +++ b/llvm/lib/Target/NVPTX/NVPTXAliasAnalysis.h @@ -85,23 +85,16 @@ class NVPTXAAWrapperPass : public ImmutablePass { // Wrapper around ExternalAAWrapperPass so that the default // constructor gets the callback. -// Note that NVPTXAA will run before BasicAA for compile time considerations. class NVPTXExternalAAWrapper : public ExternalAAWrapperPass { public: static char ID; - bool runEarly() override { return true; } - NVPTXExternalAAWrapper() : ExternalAAWrapperPass([](Pass &P, Function &, AAResults &AAR) { if (auto *WrapperPass = P.getAnalysisIfAvailable<NVPTXAAWrapperPass>()) AAR.addAAResult(WrapperPass->getResult()); }) {} - - StringRef getPassName() const override { - return "NVPTX Address space based Alias Analysis Wrapper"; - } }; ImmutablePass *createNVPTXAAWrapperPass(); diff --git a/llvm/lib/Target/NVPTX/NVPTXTargetMachine.cpp b/llvm/lib/Target/NVPTX/NVPTXTargetMachine.cpp index 85d28a703a4cb..f2e149063764d 100644 --- a/llvm/lib/Target/NVPTX/NVPTXTargetMachine.cpp +++ b/llvm/lib/Target/NVPTX/NVPTXTargetMachine.cpp @@ -234,7 +234,7 @@ MachineFunctionInfo *NVPTXTargetMachine::createMachineFunctionInfo( F, STI); } -void NVPTXTargetMachine::registerEarlyDefaultAliasAnalyses(AAManager &AAM) { +void NVPTXTargetMachine::registerDefaultAliasAnalyses(AAManager &AAM) { AAM.registerFunctionAnalysis<NVPTXAA>(); } @@ -349,7 +349,10 @@ void NVPTXPassConfig::addIRPasses() { disablePass(&RemoveLoadsIntoFakeUsesID); addPass(createNVPTXAAWrapperPass()); - addPass(createNVPTXExternalAAWrapperPass()); + addPass(createExternalAAWrapperPass([](Pass &P, Function &, AAResults &AAR) { + if (auto *WrapperPass = P.getAnalysisIfAvailable<NVPTXAAWrapperPass>()) + AAR.addAAResult(WrapperPass->getResult()); + })); // NVVMReflectPass is added in addEarlyAsPossiblePasses, so hopefully running // it here does nothing. But since we need it for correctness when lowering diff --git a/llvm/lib/Target/NVPTX/NVPTXTargetMachine.h b/llvm/lib/Target/NVPTX/NVPTXTargetMachine.h index 118a01a0352f5..34d841cd28404 100644 --- a/llvm/lib/Target/NVPTX/NVPTXTargetMachine.h +++ b/llvm/lib/Target/NVPTX/NVPTXTargetMachine.h @@ -64,7 +64,7 @@ class NVPTXTargetMachine : public CodeGenTargetMachineImpl { createMachineFunctionInfo(BumpPtrAllocator &Allocator, const Function &F, const TargetSubtargetInfo *STI) const override; - void registerEarlyDefaultAliasAnalyses(AAManager &AAM) override; + void registerDefaultAliasAnalyses(AAManager &AAM) override; void registerPassBuilderCallbacks(PassBuilder &PB) override; diff --git a/llvm/test/Analysis/NVPTXAA/NVPTXAA_before_BasicAA.ll b/llvm/test/Analysis/NVPTXAA/NVPTXAA_before_BasicAA.ll deleted file mode 100644 index 0d16b344e9f66..0000000000000 --- a/llvm/test/Analysis/NVPTXAA/NVPTXAA_before_BasicAA.ll +++ /dev/null @@ -1,17 +0,0 @@ -; REQUIRES: asserts -; RUN: opt -aa-pipeline=default -passes='require<aa>' -debug-pass-manager -disable-output -S < %s 2>&1 | FileCheck %s -; RUN: llc --debug-only='aa' -o /dev/null %s 2>&1 | FileCheck %s -check-prefix=LEGACY - -; In default AA pipeline, NVPTXAA should run before BasicAA to reduce compile time for NVPTX backend -target triple = "nvptx64-nvidia-cuda" - -; CHECK: Running analysis: NVPTXAA on foo -; CHECK-NEXT: Running analysis: BasicAA on foo - -; LEGACY: AAResults register Early ExternalAA: NVPTX Address space based Alias Analysis Wrapper -; LEGACY-NEXT: AAResults register BasicAA -define void @foo(){ -entry: - ret void -} - _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
