Revert "[AA] Move Target Specific AA before BasicAA (#125965)"

This reverts commit 94d9336.

Author: Chengjunp

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();
   }

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 &) {}

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;

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.

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();

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

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;