Make dependency between certain analysis passes transitive

[bjope]

Summary

LazyBlockFrequenceInfoPass, LazyBranchProbabilityInfoPass and
LoopAccessLegacyAnalysis all cache pointers to their nestled required
analysis passes. One need to use addRequiredTransitive to describe
that the nestled passes can't be freed until those analysis passes
no longer are used themselves.

There is still a bit of a mess considering the getLazyBPIAnalysisUsage
and getLazyBFIAnalysisUsage functions. Those functions are used from
both Transform, CodeGen and Analysis passes. I figure it is OK to
use addRequiredTransitive also when being used from Transform and
CodeGen passes. On the other hand, I figure we must to do it when
used from other Analysis passes. So using addRequiredTransitive should
be more correct here. An alternative solution would be to add a
bool option in those functions to let the user tell if it is a
analysis pass or not. Since those lazy passes will be obsolete when
new PM has conquered the world I figure we can leave it like this
right now.

Intention with the patch is to fix PR49950. It at least solves the
problem for the reproducer in PR49950. However, that reproducer
need five passes in a specific order, so there are lots of various
"solutions" that could avoid the crash without actually fixing the
root cause.

llvm/lib/Analysis/LazyBlockFrequencyInfo.cpp

 //===- LazyBlockFrequencyInfo.cpp - Lazy Block Frequency Analysis ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
void LazyBlockFrequencyInfoPass::print(raw_ostream &OS, const Module *) const {
   LBFI.getCalculated().print(OS);
 }
 
 void LazyBlockFrequencyInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
   LazyBranchProbabilityInfoPass::getLazyBPIAnalysisUsage(AU);
   // We require DT so it's available when LI is available. The LI updating code
   // asserts that DT is also present so if we don't make sure that we have DT
   // here, that assert will trigger.
-  AU.addRequired<DominatorTreeWrapperPass>();
-  AU.addRequired<LoopInfoWrapperPass>();
+  AU.addRequiredTransitive<DominatorTreeWrapperPass>();
+  AU.addRequiredTransitive<LoopInfoWrapperPass>();
   AU.setPreservesAll();
 }
 
 void LazyBlockFrequencyInfoPass::releaseMemory() { LBFI.releaseMemory(); }
 
 bool LazyBlockFrequencyInfoPass::runOnFunction(Function &F) {
   auto &BPIPass = getAnalysis<LazyBranchProbabilityInfoPass>();
   LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   LBFI.setAnalysis(&F, &BPIPass, &LI);
   return false;
 }
 
 void LazyBlockFrequencyInfoPass::getLazyBFIAnalysisUsage(AnalysisUsage &AU) {
   LazyBranchProbabilityInfoPass::getLazyBPIAnalysisUsage(AU);
-  AU.addRequired<LazyBlockFrequencyInfoPass>();
-  AU.addRequired<LoopInfoWrapperPass>();
+  AU.addRequiredTransitive<LazyBlockFrequencyInfoPass>();
+  AU.addRequiredTransitive<LoopInfoWrapperPass>();
 }
 
 void llvm::initializeLazyBFIPassPass(PassRegistry &Registry) {
   initializeLazyBPIPassPass(Registry);
   INITIALIZE_PASS_DEPENDENCY(LazyBlockFrequencyInfoPass);
   INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 }

llvm/lib/Analysis/LazyBranchProbabilityInfo.cpp

 //===- LazyBranchProbabilityInfo.cpp - Lazy Branch Probability Analysis ---===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
void LazyBranchProbabilityInfoPass::print(raw_ostream &OS,
                                           const Module *) const {
   LBPI->getCalculated().print(OS);
 }
 
 void LazyBranchProbabilityInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
   // We require DT so it's available when LI is available. The LI updating code
   // asserts that DT is also present so if we don't make sure that we have DT
   // here, that assert will trigger.
-  AU.addRequired<DominatorTreeWrapperPass>();
-  AU.addRequired<LoopInfoWrapperPass>();
-  AU.addRequired<TargetLibraryInfoWrapperPass>();
+  AU.addRequiredTransitive<DominatorTreeWrapperPass>();
+  AU.addRequiredTransitive<LoopInfoWrapperPass>();
+  AU.addRequiredTransitive<TargetLibraryInfoWrapperPass>();
   AU.setPreservesAll();
 }
 
 void LazyBranchProbabilityInfoPass::releaseMemory() { LBPI.reset(); }
 
 bool LazyBranchProbabilityInfoPass::runOnFunction(Function &F) {
   LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   TargetLibraryInfo &TLI =
       getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
   LBPI = std::make_unique<LazyBranchProbabilityInfo>(&F, &LI, &TLI);
   return false;
 }
 
 void LazyBranchProbabilityInfoPass::getLazyBPIAnalysisUsage(AnalysisUsage &AU) {
-  AU.addRequired<LazyBranchProbabilityInfoPass>();
-  AU.addRequired<LoopInfoWrapperPass>();
-  AU.addRequired<TargetLibraryInfoWrapperPass>();
+  AU.addRequiredTransitive<LazyBranchProbabilityInfoPass>();
+  AU.addRequiredTransitive<LoopInfoWrapperPass>();
+  AU.addRequiredTransitive<TargetLibraryInfoWrapperPass>();
 }
 
 void llvm::initializeLazyBPIPassPass(PassRegistry &Registry) {
   INITIALIZE_PASS_DEPENDENCY(LazyBranchProbabilityInfoPass);
   INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
   INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass);
 }

llvm/lib/Analysis/LoopAccessAnalysis.cpp

 //===- LoopAccessAnalysis.cpp - Loop Access Analysis Implementation --------==//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
bool LoopAccessLegacyAnalysis::runOnFunction(Function &F) {
   AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
 
   return false;
 }
 
 void LoopAccessLegacyAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<ScalarEvolutionWrapperPass>();
-    AU.addRequired<AAResultsWrapperPass>();
-    AU.addRequired<DominatorTreeWrapperPass>();
-    AU.addRequired<LoopInfoWrapperPass>();
+    AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
+    AU.addRequiredTransitive<AAResultsWrapperPass>();
+    AU.addRequiredTransitive<DominatorTreeWrapperPass>();
+    AU.addRequiredTransitive<LoopInfoWrapperPass>();
 
     AU.setPreservesAll();
 }
 
 char LoopAccessLegacyAnalysis::ID = 0;
 static const char laa_name[] = "Loop Access Analysis";
 #define LAA_NAME "loop-accesses"
 
 INITIALIZE_PASS_BEGIN(LoopAccessLegacyAnalysis, LAA_NAME, laa_name, false, true)
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)

llvm/test/Other/pr49950.ll

+; RUN: opt < %s -o /dev/null -enable-new-pm=0 -block-freq -opt-remark-emitter -memoryssa -inject-tli-mappings -pgo-memop-opt -verify-loop-info -debug-pass=Details 2>&1 | FileCheck %s
+
+; REQUIRES: asserts
+
+; This is a heavily reduced reproducer for the problem found in
+; https://bugs.llvm.org/show_bug.cgi?id=49950 when doing fuzzy
+; testing (including non-standard pipelines).
+;
+; The problem manifested as having a pass structure like this
+; when it failed (as given by using -debug-pass=Details):
+;
+;   Target Library Information
+;   Target Transform Information
+;   Profile summary info
+;   Assumption Cache Tracker
+;     ModulePass Manager
+;       FunctionPass Manager
+;         Dominator Tree Construction
+;         Natural Loop Information
+;         Post-Dominator Tree Construction
+;         Branch Probability Analysis
+;         Block Frequency Analysis
+;   --      Branch Probability Analysis
+;         Lazy Branch Probability Analysis
+;         Lazy Block Frequency Analysis
+;         Optimization Remark Emitter
+;         Basic Alias Analysis (stateless AA impl)
+;         Function Alias Analysis Results
+;         Memory SSA
+;   --      Dominator Tree Construction
+;   --      Function Alias Analysis Results
+;   --      Basic Alias Analysis (stateless AA impl)
+;   --      Memory SSA
+;         Inject TLI Mappings
+;   --      Inject TLI Mappings
+;         PGOMemOPSize
+;   --      Block Frequency Analysis
+;   --      Post-Dominator Tree Construction
+;   --      Optimization Remark Emitter
+;   --      Lazy Branch Probability Analysis
+;   --      Natural Loop Information
+;   --      Lazy Block Frequency Analysis
+;   --      PGOMemOPSize
+;         Module Verifier
+;   --      Module Verifier
+;   --    Target Library Information
+;   --    Profile summary info
+;   --    Assumption Cache Tracker
+;       Bitcode Writer
+;   --    Bitcode Writer
+;
+; One might notice that "Dominator Tree Construction" is dropped after
+; "Memory SSA", while for example "Natural Loop Information" stick around
+; a bit longer. This despite "Dominator Tree Construction" being transitively
+; required by "Natural Loop Information".
+; The end result was that we got crashes when doing verification of loop
+; info after "Inject TLI Mappings" (since the dominator tree had been
+; removed too early).
+
+; Verify that both domintator tree and loop info are kept until after
+; PGOMemOPSize:
+;
+; CHECK:     Dominator Tree Construction
+; CHECK-NOT: --      Dominator Tree Construction
+; CHECK:     Memory SSA
+; CHECK-NOT: --      Dominator Tree Construction
+; CHECK:     Inject TLI Mappings
+; CHECK-NOT: --      Dominator Tree Construction
+; CHECK:     PGOMemOPSize
+; CHECK-DAG: --      Dominator Tree Construction
+; CHECK-DAG: --      Natural Loop Information
+; CHECK-DAG: --      PGOMemOPSize
+; CHECK:     Bitcode Writer
+
+define void @foo() {
+entry:
+  ret void
+}
 No newline at end of file