[Analysis] Deprecate (Legacy)DivergenceAnalysis

[Pierre-vh]

Summary

UniformityAnalysis is a superior replacement, and there are now in-tree users of those DAs left.
They will be removed in a later version. Deprecate them now so downstream users have time to change if needed.

[Pierre-vh]

Note: I deprecated the methods instead of the classes because deprecating the classes causes warning in things like PassBuilder. I'm open to changing how we implement the deprecation if anyone has an objection :)

[nikic]

I'd prefer deleting this code over adding pragmas. There is no need to deprecate things in C++ API before removal.

llvm/lib/Analysis/DivergenceAnalysis.cpp

93

Won't this break the GCC build?

[Pierre-vh]

In D146940#4232995, @nikic wrote:

I'd prefer deleting this code over adding pragmas. There is no need to deprecate things in C++ API before removal.

I thought we needed to deprecate the analysis first if there are downstream users. Is there a precedent for removing an analysis directly without deprecation?
If so, can you please mention it in the RFC? https://discourse.llvm.org/t/rfc-deprecate-divergenceanalysis-legacydivergenceanalysis/69538/4

I'd also rather just delete it now - especially because there's no reason not to use UA, but I thought deprecation was a mandatory step.

[arsenm]

In D146940#4233004, @Pierre-vh wrote:

I'd also rather just delete it now - especially because there's no reason not to use UA, but I thought deprecation was a mandatory step.

This isn't major enough to bother deprecating. The only place we might bother with deprecation is really the C API, or long-term migrations in core APIs (e.g. the pointer element type getters)

[Pierre-vh]

In D146940#4233023, @arsenm wrote:

In D146940#4233004, @Pierre-vh wrote:

I'd also rather just delete it now - especially because there's no reason not to use UA, but I thought deprecation was a mandatory step.

This isn't major enough to bother deprecating. The only place we might bother with deprecation is really the C API, or long-term migrations in core APIs (e.g. the pointer element type getters)

That makes sense, I agree. Migration is also extremely straightforward for downstream users.
I added a comment on the RFC and will give it a few days in case someone has an objection, in the meantime I'll remove this from review queues.

llvm/include/llvm/Analysis/DivergenceAnalysis.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_DIVERGENCEANALYSIS_H
 #define LLVM_ANALYSIS_DIVERGENCEANALYSIS_H
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Analysis/SyncDependenceAnalysis.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Support/Compiler.h"
 #include <vector>
 
 namespace llvm {
 class Function;
 class Instruction;
 class Loop;
 class raw_ostream;
 class TargetTransformInfo;
class DivergenceInfo {
   std::unique_ptr<DivergenceAnalysisImpl> DA;
 
 public:
   DivergenceInfo(Function &F, const DominatorTree &DT,
                  const PostDominatorTree &PDT, const LoopInfo &LI,
                  const TargetTransformInfo &TTI, bool KnownReducible);
 
   /// Whether any divergence was detected.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   bool hasDivergence() const {
     return ContainsIrreducible || DA->hasDetectedDivergence();
   }
 
   /// The GPU kernel this analysis result is for
   const Function &getFunction() const { return F; }
 
   /// Whether \p V is divergent at its definition.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   bool isDivergent(const Value &V) const {
     return ContainsIrreducible || DA->isDivergent(V);
   }
 
   /// Whether \p U is divergent. Uses of a uniform value can be divergent.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   bool isDivergentUse(const Use &U) const {
     return ContainsIrreducible || DA->isDivergentUse(U);
   }
 
   /// Whether \p V is uniform/non-divergent.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   bool isUniform(const Value &V) const { return !isDivergent(V); }
 
   /// Whether \p U is uniform/non-divergent. Uses of a uniform value can be
   /// divergent.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   bool isUniformUse(const Use &U) const { return !isDivergentUse(U); }
 };
 
 /// \brief Divergence analysis frontend for GPU kernels.
 class DivergenceAnalysis : public AnalysisInfoMixin<DivergenceAnalysis> {
   friend AnalysisInfoMixin<DivergenceAnalysis>;
 
   static AnalysisKey Key;

llvm/include/llvm/Analysis/LegacyDivergenceAnalysis.h

 #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 "llvm/Support/Compiler.h"
 #include <memory>
 
 namespace llvm {
 class DivergenceInfo;
 class Function;
 class Module;
 class raw_ostream;
 class TargetTransformInfo;
 class Use;
 class Value;
 
 class LegacyDivergenceAnalysisImpl {
 public:
   // Returns true if V is divergent at its definition.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   bool isDivergent(const Value *V) const;
 
   // Returns true if U is divergent. Uses of a uniform value can be divergent.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   bool isDivergentUse(const Use *U) const;
 
   // Returns true if V is uniform/non-divergent.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   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.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   bool isUniformUse(const Use *U) const { return !isDivergentUse(U); }
 
   // Keep the analysis results uptodate by removing an erased value.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   void removeValue(const Value *V) { DivergentValues.erase(V); }
 
   // Print all divergent branches in the function.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   void print(raw_ostream &OS, const Module *) const;
 
   // Whether analysis should be performed by GPUDivergenceAnalysis.
+  LLVM_DEPRECATED("Use UniformityAnalysis instead", "UniformityAnalysis")
   bool shouldUseGPUDivergenceAnalysis(const Function &F,
                                       const TargetTransformInfo &TTI,
                                       const LoopInfo &LI);
 
   void run(Function &F, TargetTransformInfo &TTI, DominatorTree &DT,
            PostDominatorTree &PDT, const LoopInfo &LI);
 
 protected:

llvm/lib/Analysis/DivergenceAnalysis.cpp

 #include "llvm/IR/Value.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "divergence"
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
 DivergenceAnalysisImpl::DivergenceAnalysisImpl(
     const Function &F, const Loop *RegionLoop, const DominatorTree &DT,
     const LoopInfo &LI, SyncDependenceAnalysis &SDA, bool IsLCSSAForm)
     : F(F), RegionLoop(RegionLoop), DT(DT), LI(LI), SDA(SDA),
       IsLCSSAForm(IsLCSSAForm) {}
 
 bool DivergenceAnalysisImpl::markDivergent(const Value &DivVal) {
   if (isAlwaysUniform(DivVal))
for (const BasicBlock &BB : F) {
       for (const auto &I : BB.instructionsWithoutDebug()) {
         OS << (DI.isDivergent(I) ? "DIVERGENT:     " : "               ");
         OS << I << "\n";
       }
     }
   }
   return PreservedAnalyses::all();
 }
+
+#pragma clang diagnostic pop

llvm/lib/Analysis/LegacyDivergenceAnalysis.cpp

 #define DEBUG_TYPE "divergence"
 
 // transparently use the GPUDivergenceAnalysis
 static cl::opt<bool> UseGPUDA("use-gpu-divergence-analysis", cl::init(false),
                               cl::Hidden,
                               cl::desc("turn the LegacyDivergenceAnalysis into "
                                        "a wrapper for GPUDivergenceAnalysis"));
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
 namespace {
 
 class DivergencePropagator {
 public:
   DivergencePropagator(Function &F, TargetTransformInfo &TTI, DominatorTree &DT,
                        PostDominatorTree &PDT, DenseSet<const Value *> &DV,
                        DenseSet<const Use *> &DU)
       : F(F), TTI(TTI), DT(DT), PDT(PDT), DV(DV), DU(DU) {}
LegacyDivergenceAnalysisPass::run(Function &F, FunctionAnalysisManager &AM) {
   auto &PDT = AM.getResult<PostDominatorTreeAnalysis>(F);
   auto &LI = AM.getResult<LoopAnalysis>(F);
   LegacyDivergenceAnalysisImpl::run(F, TTI, DT, PDT, LI);
   LLVM_DEBUG(dbgs() << "\nAfter divergence analysis on " << F.getName()
                     << ":\n";
              LegacyDivergenceAnalysisImpl::print(dbgs(), F.getParent()));
   return PreservedAnalyses::all();
 }
+
+#pragma clang diagnostic pop

llvm/unittests/Analysis/DivergenceAnalysisTest.cpp

 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/SourceMgr.h"
 #include "gtest/gtest.h"
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
 namespace llvm {
 namespace {
 
 BasicBlock *GetBlockByName(StringRef BlockName, Function &F) {
   for (auto &BB : F) {
     if (BB.getName() != BlockName)
       continue;
     return &BB;
TEST_F(DivergenceAnalysisTest, DASwitchUnreachableDefault) {
   // The join uni.dbl is not divergent (see D52221)
   auto &ExitBlock = *GetBlockByName("sw.epilog", *F);
   auto &DivDblPhi = *cast<PHINode>(ExitBlock.begin());
   EXPECT_TRUE(DA.isDivergent(DivDblPhi));
 }
 
 } // end anonymous namespace
 } // end namespace llvm
+
+#pragma clang diagnostic pop