[llvm] [UniformityAnalysis] Skip CycleAnalysis on targets without branch divergence (PR #189948)

[Pankaj Dwivedi via llvm-commits]

https://github.com/PankajDwivedi-25 updated https://github.com/llvm/llvm-project/pull/189948

>From 42925116ead942ce6b79863451738b8991fd12a3 Mon Sep 17 00:00:00 2001
From: padivedi <padivedi at amd.com>
Date: Wed, 1 Apr 2026 17:58:06 +0530
Subject: [PATCH 1/2] Skip CycleAnalysis on targets without branch divergence

---
 llvm/include/llvm/ADT/GenericUniformityImpl.h | 14 +++++++++++
 llvm/lib/Analysis/UniformityAnalysis.cpp      | 23 ++++++++++---------
 2 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/llvm/include/llvm/ADT/GenericUniformityImpl.h b/llvm/include/llvm/ADT/GenericUniformityImpl.h
index b6c714b704a57..6af4a0e15430f 100644
--- a/llvm/include/llvm/ADT/GenericUniformityImpl.h
+++ b/llvm/include/llvm/ADT/GenericUniformityImpl.h
@@ -1289,29 +1289,43 @@ GenericUniformityInfo<ContextT>::getFunction() const {
 }
 
 /// Whether \p V is divergent at its definition.
+/// A default-constructed instance (no analysis computed) reports everything
+/// as uniform, which is conservatively correct for non-divergent targets.
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::isDivergent(ConstValueRefT V) const {
+  if (!DA)
+    return false;
   return DA->isDivergent(V);
 }
 
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::isDivergent(const InstructionT *I) const {
+  if (!DA)
+    return false;
   return DA->isDivergent(*I);
 }
 
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::isDivergentUse(const UseT &U) const {
+  if (!DA)
+    return false;
   return DA->isDivergentUse(U);
 }
 
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::hasDivergentTerminator(const BlockT &B) {
+  if (!DA)
+    return false;
   return DA->hasDivergentTerminator(B);
 }
 
 /// \brief T helper function for printing.
 template <typename ContextT>
 void GenericUniformityInfo<ContextT>::print(raw_ostream &out) const {
+  if (!DA) {
+    out << "  Uniformity analysis not computed (no branch divergence).\n";
+    return;
+  }
   DA->print(out);
 }
 
diff --git a/llvm/lib/Analysis/UniformityAnalysis.cpp b/llvm/lib/Analysis/UniformityAnalysis.cpp
index 55cba19ceec14..41519bcd09baa 100644
--- a/llvm/lib/Analysis/UniformityAnalysis.cpp
+++ b/llvm/lib/Analysis/UniformityAnalysis.cpp
@@ -167,14 +167,13 @@ template struct llvm::GenericUniformityAnalysisImplDeleter<
 
 llvm::UniformityInfo UniformityInfoAnalysis::run(Function &F,
                                                  FunctionAnalysisManager &FAM) {
-  auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
   auto &TTI = FAM.getResult<TargetIRAnalysis>(F);
+  if (!TTI.hasBranchDivergence(&F))
+    return UniformityInfo{};
+  auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
   auto &CI = FAM.getResult<CycleAnalysis>(F);
   UniformityInfo UI{DT, CI, &TTI};
-  // Skip computation if we can assume everything is uniform.
-  if (TTI.hasBranchDivergence(&F))
-    UI.compute();
-
+  UI.compute();
   return UI;
 }
 
@@ -215,18 +214,20 @@ void UniformityInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
 }
 
 bool UniformityInfoWrapperPass::runOnFunction(Function &F) {
-  auto &cycleInfo = getAnalysis<CycleInfoWrapperPass>().getResult();
-  auto &domTree = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   auto &targetTransformInfo =
       getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
 
   m_function = &F;
-  m_uniformityInfo = UniformityInfo{domTree, cycleInfo, &targetTransformInfo};
 
-  // Skip computation if we can assume everything is uniform.
-  if (targetTransformInfo.hasBranchDivergence(m_function))
-    m_uniformityInfo.compute();
+  if (!targetTransformInfo.hasBranchDivergence(m_function)) {
+    m_uniformityInfo = UniformityInfo{};
+    return false;
+  }
 
+  auto &cycleInfo = getAnalysis<CycleInfoWrapperPass>().getResult();
+  auto &domTree = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+  m_uniformityInfo = UniformityInfo{domTree, cycleInfo, &targetTransformInfo};
+  m_uniformityInfo.compute();
   return false;
 }
 

>From 6837e7afcd83c135a4cd42b59b73bf284c2c2b7f Mon Sep 17 00:00:00 2001
From: padivedi <padivedi at amd.com>
Date: Thu, 2 Apr 2026 17:34:53 +0530
Subject: [PATCH 2/2] review: address suggestion

---
 llvm/include/llvm/ADT/GenericUniformityImpl.h | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/llvm/include/llvm/ADT/GenericUniformityImpl.h b/llvm/include/llvm/ADT/GenericUniformityImpl.h
index 6af4a0e15430f..d5859981ce1a7 100644
--- a/llvm/include/llvm/ADT/GenericUniformityImpl.h
+++ b/llvm/include/llvm/ADT/GenericUniformityImpl.h
@@ -1293,30 +1293,22 @@ GenericUniformityInfo<ContextT>::getFunction() const {
 /// as uniform, which is conservatively correct for non-divergent targets.
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::isDivergent(ConstValueRefT V) const {
-  if (!DA)
-    return false;
-  return DA->isDivergent(V);
+  return DA && DA->isDivergent(V);
 }
 
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::isDivergent(const InstructionT *I) const {
-  if (!DA)
-    return false;
-  return DA->isDivergent(*I);
+  return DA && DA->isDivergent(*I);
 }
 
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::isDivergentUse(const UseT &U) const {
-  if (!DA)
-    return false;
-  return DA->isDivergentUse(U);
+  return DA && DA->isDivergentUse(U);
 }
 
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::hasDivergentTerminator(const BlockT &B) {
-  if (!DA)
-    return false;
-  return DA->hasDivergentTerminator(B);
+  return DA && DA->hasDivergentTerminator(B);
 }
 
 /// \brief T helper function for printing.