[LegacyDivergenceAnalysis] Add NewPM support

[gandhi21299]

Applied clang-format

[gandhi21299]

• Correct checks in always-uniform.ll

[arsenm]

llvm/lib/Analysis/LegacyDivergenceAnalysis.cpp

421

No TTI probably shouldn’t be allowed

[gandhi21299]

llvm/lib/Analysis/LegacyDivergenceAnalysis.cpp

421

L421 already checks for that, doesn't it?

[gandhi21299]

• Fixed debug prints in both PM versions

[arsenm]

llvm/lib/Analysis/LegacyDivergenceAnalysis.cpp

421

I'm saying it shouldn't need to. What happens if you run opt without a triple?

[gandhi21299]

• Use getResult instead of getCachedResult

[gandhi21299]

llvm/lib/Analysis/LegacyDivergenceAnalysis.cpp

421

After the changes I just made, LegacyDA withdraws at L419 when -mtriple=... is not passed.

[gandhi21299]

Thanks for the review Matt, I will commit this patch.

llvm/include/llvm/Analysis/LegacyDivergenceAnalysis.h

 // branch optimizations such as jump threading and loop unswitching to make
 // better decisions.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_ANALYSIS_LEGACYDIVERGENCEANALYSIS_H
 #define LLVM_ANALYSIS_LEGACYDIVERGENCEANALYSIS_H
 
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/PostDominators.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include <memory>
 
 namespace llvm {
 class DivergenceInfo;
 class Function;
 class Module;
 class raw_ostream;
 class TargetTransformInfo;
 class Use;
 class Value;
 
-class LegacyDivergenceAnalysis : public FunctionPass {
+class LegacyDivergenceAnalysisImpl {
 public:
-  static char ID;
-
-  LegacyDivergenceAnalysis();
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override;
-
-  bool runOnFunction(Function &F) override;
-
-  // Print all divergent branches in the function.
-  void print(raw_ostream &OS, const Module *) const override;
-
   // Returns true if V is divergent at its definition.
   bool isDivergent(const Value *V) const;
 
   // Returns true if U is divergent. Uses of a uniform value can be divergent.
   bool isDivergentUse(const Use *U) const;
 
   // Returns true if V is uniform/non-divergent.
   bool isUniform(const Value *V) const { return !isDivergent(V); }
 
   // Returns true if U is uniform/non-divergent. Uses of a uniform value can be
   // divergent.
   bool isUniformUse(const Use *U) const { return !isDivergentUse(U); }
 
   // Keep the analysis results uptodate by removing an erased value.
   void removeValue(const Value *V) { DivergentValues.erase(V); }
 
-private:
+  // Print all divergent branches in the function.
+  void print(raw_ostream &OS, const Module *) const;
+
   // Whether analysis should be performed by GPUDivergenceAnalysis.
   bool shouldUseGPUDivergenceAnalysis(const Function &F,
-                                      const TargetTransformInfo &TTI) const;
+                                      const TargetTransformInfo &TTI,
+                                      const LoopInfo &LI);
+
+  void run(Function &F, TargetTransformInfo &TTI, DominatorTree &DT,
+           PostDominatorTree &PDT, const LoopInfo &LI);
+
+protected:
+  // (optional) handle to new DivergenceAnalysis
+  std::unique_ptr<DivergenceInfo> gpuDA;
+
+  // Stores all divergent values.
+  DenseSet<const Value *> DivergentValues;
+
+  // Stores divergent uses of possibly uniform values.
+  DenseSet<const Use *> DivergentUses;
+};
+
+class LegacyDivergenceAnalysis : public FunctionPass,
+                                 public LegacyDivergenceAnalysisImpl {
+public:
+  static char ID;
 
+  LegacyDivergenceAnalysis();
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  bool runOnFunction(Function &F) override;
+};
+
+class LegacyDivergenceAnalysisPass
+    : public PassInfoMixin<LegacyDivergenceAnalysisPass>,
+      public LegacyDivergenceAnalysisImpl {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+private:
   // (optional) handle to new DivergenceAnalysis
   std::unique_ptr<DivergenceInfo> gpuDA;
 
   // Stores all divergent values.
   DenseSet<const Value *> DivergentValues;
 
   // Stores divergent uses of possibly uniform values.
   DenseSet<const Use *> DivergentUses;
 };
-} // End llvm namespace
+
+} // end namespace llvm
 
 #endif // LLVM_ANALYSIS_LEGACYDIVERGENCEANALYSIS_H

llvm/lib/Analysis/LegacyDivergenceAnalysis.cpp

 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 INITIALIZE_PASS_END(LegacyDivergenceAnalysis, "divergence",
                     "Legacy Divergence Analysis", false, true)
 
 FunctionPass *llvm::createLegacyDivergenceAnalysisPass() {
   return new LegacyDivergenceAnalysis();
 }
 
-void LegacyDivergenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.addRequiredTransitive<DominatorTreeWrapperPass>();
-  AU.addRequiredTransitive<PostDominatorTreeWrapperPass>();
-  AU.addRequiredTransitive<LoopInfoWrapperPass>();
-  AU.setPreservesAll();
-}
-
-bool LegacyDivergenceAnalysis::shouldUseGPUDivergenceAnalysis(
-    const Function &F, const TargetTransformInfo &TTI) const {
+bool LegacyDivergenceAnalysisImpl::shouldUseGPUDivergenceAnalysis(
+    const Function &F, const TargetTransformInfo &TTI, const LoopInfo &LI) {
   if (!(UseGPUDA || TTI.useGPUDivergenceAnalysis()))
     return false;
 
   // GPUDivergenceAnalysis requires a reducible CFG.
-  auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   using RPOTraversal = ReversePostOrderTraversal<const Function *>;
   RPOTraversal FuncRPOT(&F);
   return !containsIrreducibleCFG<const BasicBlock *, const RPOTraversal,
                                  const LoopInfo>(FuncRPOT, LI);
 }
 
-bool LegacyDivergenceAnalysis::runOnFunction(Function &F) {
-  auto *TTIWP = getAnalysisIfAvailable<TargetTransformInfoWrapperPass>();
-  if (TTIWP == nullptr)
-    return false;
-
-  TargetTransformInfo &TTI = TTIWP->getTTI(F);
-  // Fast path: if the target does not have branch divergence, we do not mark
-  // any branch as divergent.
-  if (!TTI.hasBranchDivergence())
-    return false;
-
-  DivergentValues.clear();
-  DivergentUses.clear();
-  gpuDA = nullptr;
-
-  auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
-  auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
-
-  if (shouldUseGPUDivergenceAnalysis(F, TTI)) {
+void LegacyDivergenceAnalysisImpl::run(Function &F,
+                                       llvm::TargetTransformInfo &TTI,
+                                       llvm::DominatorTree &DT,
+                                       llvm::PostDominatorTree &PDT,
+                                       const llvm::LoopInfo &LI) {
+  if (shouldUseGPUDivergenceAnalysis(F, TTI, LI)) {
     // run the new GPU divergence analysis
-    auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
     gpuDA = std::make_unique<DivergenceInfo>(F, DT, PDT, LI, TTI,
                                              /* KnownReducible  = */ true);
 
   } else {
     // run LLVM's existing DivergenceAnalysis
     DivergencePropagator DP(F, TTI, DT, PDT, DivergentValues, DivergentUses);
     DP.populateWithSourcesOfDivergence();
     DP.propagate();
   }
 
   LLVM_DEBUG(dbgs() << "\nAfter divergence analysis on " << F.getName()
                     << ":\n";
              print(dbgs(), F.getParent()));
-
-  return false;
 }
 
-bool LegacyDivergenceAnalysis::isDivergent(const Value *V) const {
+bool LegacyDivergenceAnalysisImpl::isDivergent(const Value *V) const {
   if (gpuDA) {
     return gpuDA->isDivergent(*V);
   }
   return DivergentValues.count(V);
 }
 
-bool LegacyDivergenceAnalysis::isDivergentUse(const Use *U) const {
+bool LegacyDivergenceAnalysisImpl::isDivergentUse(const Use *U) const {
   if (gpuDA) {
     return gpuDA->isDivergentUse(*U);
   }
   return DivergentValues.count(U->get()) || DivergentUses.count(U);
 }
 
-void LegacyDivergenceAnalysis::print(raw_ostream &OS, const Module *) const {
+void LegacyDivergenceAnalysisImpl::print(raw_ostream &OS,
+                                         const Module *) const {
   if ((!gpuDA || !gpuDA->hasDivergence()) && DivergentValues.empty())
     return;
 
   const Function *F = nullptr;
   if (!DivergentValues.empty()) {
     const Value *FirstDivergentValue = *DivergentValues.begin();
     if (const Argument *Arg = dyn_cast<Argument>(FirstDivergentValue)) {
       F = Arg->getParent();
for (const BasicBlock &BB : *F) {
     OS << "\n           " << BB.getName() << ":\n";
     for (const auto &I : BB.instructionsWithoutDebug()) {
       OS << (isDivergent(&I) ? "DIVERGENT:     " : "               ");
       OS << I << "\n";
     }
   }
   OS << "\n";
 }
+
+void LegacyDivergenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.addRequiredTransitive<DominatorTreeWrapperPass>();
+  AU.addRequiredTransitive<PostDominatorTreeWrapperPass>();
+  AU.addRequiredTransitive<LoopInfoWrapperPass>();
+  AU.setPreservesAll();
+}
+
+bool LegacyDivergenceAnalysis::runOnFunction(Function &F) {
+  auto *TTIWP = getAnalysisIfAvailable<TargetTransformInfoWrapperPass>();
+  if (TTIWP == nullptr)
+    return false;
+
+  TargetTransformInfo &TTI = TTIWP->getTTI(F);
+  // Fast path: if the target does not have branch divergence, we do not mark
+  // any branch as divergent.
+  if (!TTI.hasBranchDivergence())
+    return false;
+
+  DivergentValues.clear();
+  DivergentUses.clear();
+  gpuDA = nullptr;
+
+  auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+  auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
+  auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
+  run(F, TTI, DT, PDT, LI);
+  LegacyDivergenceAnalysisImpl::print(dbgs(), F.getParent());
+  return false;
+}
+
+PreservedAnalyses
+LegacyDivergenceAnalysisPass::run(Function &F, FunctionAnalysisManager &AM) {
+  auto *TTI = AM.getCachedResult<TargetIRAnalysis>(F);
+  if (!TTI || !TTI->hasBranchDivergence())
+    return PreservedAnalyses::all();
+
+  DivergentValues.clear();
+  DivergentUses.clear();
+  gpuDA = nullptr;
+
+  auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
+  auto &PDT = AM.getResult<PostDominatorTreeAnalysis>(F);
+  auto &LI = AM.getResult<LoopAnalysis>(F);
+  LegacyDivergenceAnalysisImpl::run(F, *TTI, DT, PDT, LI);
+  LegacyDivergenceAnalysisImpl::print(dbgs(), F.getParent());
+  return PreservedAnalyses::all();
+}

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/IRSimilarityIdentifier.h"
 #include "llvm/Analysis/IVUsers.h"
 #include "llvm/Analysis/InlineAdvisor.h"
 #include "llvm/Analysis/InlineSizeEstimatorAnalysis.h"
 #include "llvm/Analysis/InstCount.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/LazyValueInfo.h"
+#include "llvm/Analysis/LegacyDivergenceAnalysis.h"
 #include "llvm/Analysis/Lint.h"
 #include "llvm/Analysis/LoopAccessAnalysis.h"
 #include "llvm/Analysis/LoopCacheAnalysis.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/LoopNestAnalysis.h"
 #include "llvm/Analysis/MemDerefPrinter.h"
 #include "llvm/Analysis/MemoryDependenceAnalysis.h"
 #include "llvm/Analysis/MemorySSA.h"

llvm/lib/Passes/PassRegistry.def

 FUNCTION_PASS("invalidate<all>", InvalidateAllAnalysesPass())
 FUNCTION_PASS("irce", IRCEPass())
 FUNCTION_PASS("float2int", Float2IntPass())
 FUNCTION_PASS("no-op-function", NoOpFunctionPass())
 FUNCTION_PASS("libcalls-shrinkwrap", LibCallsShrinkWrapPass())
 FUNCTION_PASS("lint", LintPass())
 FUNCTION_PASS("inject-tli-mappings", InjectTLIMappings())
 FUNCTION_PASS("instnamer", InstructionNamerPass())
+FUNCTION_PASS("legacy-divergence-analysis", LegacyDivergenceAnalysisPass())
 FUNCTION_PASS("loweratomic", LowerAtomicPass())
 FUNCTION_PASS("lower-expect", LowerExpectIntrinsicPass())
 FUNCTION_PASS("lower-guard-intrinsic", LowerGuardIntrinsicPass())
 FUNCTION_PASS("lower-constant-intrinsics", LowerConstantIntrinsicsPass())
 FUNCTION_PASS("lower-widenable-condition", LowerWidenableConditionPass())
 FUNCTION_PASS("guard-widening", GuardWideningPass())
 FUNCTION_PASS("load-store-vectorizer", LoadStoreVectorizerPass())
 FUNCTION_PASS("loop-simplify", LoopSimplifyPass())

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/atomics.ll

 ; RUN: opt -mtriple amdgcn-- -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 ; RUN: opt -mtriple amdgcn-- -passes='print<uniformity>' -disable-output %s 2>&1 | FileCheck %s
 
+; OPT-LABEL: test1
 ; CHECK: DIVERGENT: %orig = atomicrmw xchg ptr %ptr, i32 %val seq_cst
 define amdgpu_kernel void @test1(ptr %ptr, i32 %val) #0 {
   %orig = atomicrmw xchg ptr %ptr, i32 %val seq_cst
   store i32 %orig, ptr %ptr
   ret void
 }
 
 ; CHECK: DIVERGENT: %orig = cmpxchg ptr %ptr, i32 %cmp, i32 %new seq_cst seq_cst

llvm/test/CodeGen/AMDGPU/always-uniform.ll

+; RUN: opt -mtriple amdgcn-amdhsa -mcpu=gfx90a -passes=legacy-divergence-analysis < %s -S 2>&1 | FileCheck -check-prefix=OPT %s
 ; RUN: llc -mtriple amdgcn-amdhsa -mcpu=fiji -amdgpu-scalarize-global-loads -verify-machineinstrs < %s | FileCheck -check-prefix=GCN %s
 
 declare i32 @llvm.amdgcn.workitem.id.x()
 declare i32 @llvm.amdgcn.readfirstlane(i32)
 
+; OPT-LABEL: readfirstlane_uniform
+; OPT: foo
 ; GCN-LABEL: readfirstlane_uniform
 ; GCN:  s_load_dwordx4 s[[[IN_ADDR:[0-9]+]]:3], s[4:5], 0x0
 ; GCN:  v_readfirstlane_b32 s[[SCALAR:[0-9]+]], v0
 ; GCN:  s_add_u32 s[[LOAD_ADDR:[0-9]+]], s[[IN_ADDR]], s[[SCALAR]]
 ; GCN:  s_load_dword s{{[0-9]+}}, s[[[LOAD_ADDR]]
 
 define amdgpu_kernel void @readfirstlane_uniform(ptr addrspace(1) noalias nocapture readonly, ptr addrspace(1) noalias nocapture readonly) {
   %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
   %scalar = tail call i32 @llvm.amdgcn.readfirstlane(i32 %tid)
   %idx = zext i32 %scalar to i64
   %gep0 = getelementptr inbounds float, ptr addrspace(1) %0, i64 %idx
   %val = load float, ptr addrspace(1) %gep0, align 4
   %gep1 = getelementptr inbounds float, ptr addrspace(1) %1, i64 10
   store float %val, ptr addrspace(1) %gep1, align 4
   ret void
 }