[LLVM] refactor GenericSSAContext and its specializations

[sameerds]

Summary

Fix the GenericSSAContext template so that it actually declares all the
necessary typenames and the methods that must be implemented by its
specializations SSAContext and MachineSSAContext.

llvm/include/llvm/ADT/GenericCycleImpl.h

template <typename ContextT> void GenericCycleInfo<ContextT>::clear() {
   BlockMap.clear();
   BlockMapTopLevel.clear();
 }
 
 /// \brief Compute the cycle info for a function.
 template <typename ContextT>
 void GenericCycleInfo<ContextT>::compute(FunctionT &F) {
   GenericCycleInfoCompute<ContextT> Compute(*this);
-  Context.setFunction(F);
+  Context = ContextT(&F);
 
   LLVM_DEBUG(errs() << "Computing cycles for function: " << F.getName()
                     << "\n");
-  Compute.run(ContextT::getEntryBlock(F));
+  Compute.run(&F.front());
 
   assert(validateTree());
 }
 
 /// \brief Find the innermost cycle containing a given block.
 ///
 /// \returns the innermost cycle containing \p Block or nullptr if
 ///          it is not contained in any cycle.

llvm/include/llvm/ADT/GenericCycleInfo.h

 public:
   GenericCycleInfo() = default;
   GenericCycleInfo(GenericCycleInfo &&) = default;
   GenericCycleInfo &operator=(GenericCycleInfo &&) = default;
 
   void clear();
   void compute(FunctionT &F);
 
-  FunctionT *getFunction() const { return Context.getFunction(); }
+  const FunctionT *getFunction() const { return Context.getFunction(); }
   const ContextT &getSSAContext() const { return Context; }
 
   CycleT *getCycle(const BlockT *Block) const;
   unsigned getCycleDepth(const BlockT *Block) const;
   CycleT *getTopLevelParentCycle(BlockT *Block);
 
   /// Methods for debug and self-test.
   //@{

llvm/include/llvm/ADT/GenericSSAContext.h

 
 #ifndef LLVM_ADT_GENERICSSACONTEXT_H
 #define LLVM_ADT_GENERICSSACONTEXT_H
 
 #include "llvm/Support/Printable.h"
 
 namespace llvm {
 
+template <typename, bool> class DominatorTreeBase;
+template <typename> class SmallVectorImpl;
+
+// Specializations of this template should provide the types used by the
+// template GenericSSAContext below.
+template <typename _FunctionT> struct GenericSSATraits;
+
+// Ideally this should have been a stateless traits class. But the print methods
+// for Machine IR need access to the owning function. So we track that state in
+// the template itself.
+//
+// We use FunctionT as a template argument and not GenericSSATraits to allow
+// forward declarations using well-known typenames.
 template <typename _FunctionT> class GenericSSAContext {
-public:
-  // Specializations should provide the following types that are similar to how
-  // LLVM IR is structured:
+  using SSATraits = GenericSSATraits<_FunctionT>;
+  const typename SSATraits::FunctionT *F;
 
+public:
   // The smallest unit of the IR is a ValueT. The SSA context uses a ValueRefT,
   // which is a pointer to a ValueT, since Machine IR does not have the
   // equivalent of a ValueT.
-  //
-  // using ValueRefT = ...
-  //
+  using ValueRefT = typename SSATraits::ValueRefT;
+
   // The ConstValueRefT is needed to work with "const Value *", where const
   // needs to bind to the pointee and not the pointer.
-  //
-  // using ConstValueRefT = ...
-  //
-  // The null value for ValueRefT.
-  //
-  // static constexpr ValueRefT ValueRefNull;
+  using ConstValueRefT = typename SSATraits::ConstValueRefT;
+
+  // The null value for ValueRefT. For LLVM IR and MIR, this is simply the
+  // default constructed value.
+  static constexpr ValueRefT *ValueRefNull = {};
 
   // An InstructionT usually defines one or more ValueT objects.
-  //
-  // using InstructionT = ... must be a subclass of Value
+  using InstructionT = typename SSATraits::InstructionT;
 
   // A UseT represents a data-edge from the defining instruction to the using
   // instruction.
-  //
-  // using UseT = ...
+  using UseT = typename SSATraits::UseT;
 
   // A BlockT is a sequence of InstructionT, and forms a node of the CFG. It
   // has global methods predecessors() and successors() that return
   // the list of incoming CFG edges and outgoing CFG edges
   // respectively.
-  //
-  // using BlockT = ...
+  using BlockT = typename SSATraits::BlockT;
 
   // A FunctionT represents a CFG along with arguments and return values. It is
   // the smallest complete unit of code in a Module.
-  //
-  // The compiler produces an error here if this class is implicitly
-  // specialized due to an instantiation. An explicit specialization
-  // of this template needs to be added before the instantiation point
-  // indicated by the compiler.
-  using FunctionT = typename _FunctionT::invalidTemplateInstanceError;
+  using FunctionT = typename SSATraits::FunctionT;
 
   // A dominator tree provides the dominance relation between basic blocks in
   // a given funciton.
-  //
-  // using DominatorTreeT = ...
+  using DominatorTreeT = DominatorTreeBase<BlockT, false>;
 
-  // Initialize the SSA context with information about the FunctionT being
-  // processed.
-  //
-  // void setFunction(FunctionT &function);
-  // FunctionT* getFunction() const;
+  GenericSSAContext() = default;
+  GenericSSAContext(const FunctionT *F) : F(F) {}
 
-  // Every FunctionT has a unique BlockT marked as its entry.
-  //
-  // static BlockT* getEntryBlock(FunctionT &F);
+  const FunctionT *getFunction() const { return F; }
 
-  // Methods to examine basic blocks and values
-  //
-  // static void appendBlockDefs(SmallVectorImpl<ValueRefT> &defs,
-  //                             BlockT &block);
-  // static void appendBlockDefs(SmallVectorImpl<const ValueRefT> &defs,
-  //                             const BlockT &block);
-
-  // static void appendBlockTerms(SmallVectorImpl<InstructionT *> &terms,
-  //                              BlockT &block);
-  // static void appendBlockTerms(SmallVectorImpl<const InstructionT *> &terms,
-  //                              const BlockT &block);
-  //
-  // static bool comesBefore(const InstructionT *lhs, const InstructionT *rhs);
-  // static bool isConstantOrUndefValuePhi(const InstructionT &Instr);
-  // const BlockT *getDefBlock(const ValueRefT value) const;
+  static void appendBlockDefs(SmallVectorImpl<ValueRefT> &defs, BlockT &block);
+  static void appendBlockDefs(SmallVectorImpl<ConstValueRefT> &defs,
+                              const BlockT &block);
 
-  // Methods to print various objects.
-  //
-  // Printable print(BlockT *block) const;
-  // Printable print(InstructionT *inst) const;
-  // Printable print(ValueRefT value) const;
+  static void appendBlockTerms(SmallVectorImpl<InstructionT *> &terms,
+                               BlockT &block);
+  static void appendBlockTerms(SmallVectorImpl<const InstructionT *> &terms,
+                               const BlockT &block);
+
+  static bool isConstantOrUndefValuePhi(const InstructionT &Instr);
+  const BlockT *getDefBlock(ConstValueRefT value) const;
+
+  Printable print(const BlockT *block) const;
+  Printable print(const InstructionT *inst) const;
+  Printable print(ConstValueRefT value) const;
 };
 } // namespace llvm
 
 #endif // LLVM_ADT_GENERICSSACONTEXT_H

llvm/include/llvm/ADT/GenericUniformityImpl.h

 
 private:
   SmallVector<const BlockT *> m_order;
   DenseMap<const BlockT *, unsigned> POIndex;
   SmallPtrSet<const BlockT *, 32> ReducibleCycleHeaders;
   const ContextT &Context;
 
   void computeCyclePO(const CycleInfoT &CI, const CycleT *Cycle,
-                      SmallPtrSetImpl<BlockT *> &Finalized);
+                      SmallPtrSetImpl<const BlockT *> &Finalized);
 
-  void computeStackPO(SmallVectorImpl<BlockT *> &Stack, const CycleInfoT &CI,
-                      const CycleT *Cycle,
-                      SmallPtrSetImpl<BlockT *> &Finalized);
+  void computeStackPO(SmallVectorImpl<const BlockT *> &Stack,
+                      const CycleInfoT &CI, const CycleT *Cycle,
+                      SmallPtrSetImpl<const BlockT *> &Finalized);
 };
 
 template <typename> class DivergencePropagator;
 
 /// \class GenericSyncDependenceAnalysis
 ///
 /// \brief Locate join blocks for disjoint paths starting at a divergent branch.
 ///
public:
   using CycleInfoT = GenericCycleInfo<ContextT>;
   using CycleT = typename CycleInfoT::CycleT;
 
   using SyncDependenceAnalysisT = GenericSyncDependenceAnalysis<ContextT>;
   using DivergenceDescriptorT =
       typename SyncDependenceAnalysisT::DivergenceDescriptor;
   using BlockLabelMapT = typename SyncDependenceAnalysisT::BlockLabelMap;
 
-  GenericUniformityAnalysisImpl(const FunctionT &F, const DominatorTreeT &DT,
-                                const CycleInfoT &CI,
+  GenericUniformityAnalysisImpl(const DominatorTreeT &DT, const CycleInfoT &CI,
                                 const TargetTransformInfo *TTI)
-      : Context(CI.getSSAContext()), F(F), CI(CI), TTI(TTI), DT(DT),
-        SDA(Context, DT, CI) {}
+      : Context(CI.getSSAContext()), F(*Context.getFunction()), CI(CI),
+        TTI(TTI), DT(DT), SDA(Context, DT, CI) {}
 
   void initialize();
 
   const FunctionT &getFunction() const { return F; }
 
   /// \brief Mark \p UniVal as a value that is always uniform.
   void addUniformOverride(const InstructionT &Instr);
 

 template <typename ContextT>
 bool GenericUniformityAnalysisImpl<ContextT>::isAlwaysUniform(
     const InstructionT &Instr) const {
   return UniformOverrides.contains(&Instr);
 }
 
 template <typename ContextT>
 GenericUniformityInfo<ContextT>::GenericUniformityInfo(
-    FunctionT &Func, const DominatorTreeT &DT, const CycleInfoT &CI,
-    const TargetTransformInfo *TTI)
-    : F(&Func) {
-  DA.reset(new ImplT{Func, DT, CI, TTI});
+    const DominatorTreeT &DT, const CycleInfoT &CI,
+    const TargetTransformInfo *TTI) {
+  DA.reset(new ImplT{DT, CI, TTI});
 }
 
 template <typename ContextT>
 void GenericUniformityAnalysisImpl<ContextT>::print(raw_ostream &OS) const {
   bool haveDivergentArgs = false;
 
   // Control flow instructions may be divergent even if their inputs are
   // uniform. Thus, although exceedingly rare, it is possible to have a program
void GenericUniformityAnalysisImpl<ContextT>::print(raw_ostream &OS) const {
   }
 }
 
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::hasDivergence() const {
   return DA->hasDivergence();
 }
 
+template <typename ContextT>
+const typename ContextT::FunctionT &
+GenericUniformityInfo<ContextT>::getFunction() const {
+  return DA->getFunction();
+}
+
 /// Whether \p V is divergent at its definition.
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::isDivergent(ConstValueRefT V) const {
   return DA->isDivergent(V);
 }
 
 template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::isDivergent(const InstructionT *I) const {

 /// \brief T helper function for printing.
 template <typename ContextT>
 void GenericUniformityInfo<ContextT>::print(raw_ostream &out) const {
   DA->print(out);
 }
 
 template <typename ContextT>
 void llvm::ModifiedPostOrder<ContextT>::computeStackPO(
-    SmallVectorImpl<BlockT *> &Stack, const CycleInfoT &CI, const CycleT *Cycle,
-    SmallPtrSetImpl<BlockT *> &Finalized) {
+    SmallVectorImpl<const BlockT *> &Stack, const CycleInfoT &CI,
+    const CycleT *Cycle, SmallPtrSetImpl<const BlockT *> &Finalized) {
   LLVM_DEBUG(dbgs() << "inside computeStackPO\n");
   while (!Stack.empty()) {
     auto *NextBB = Stack.back();
     if (Finalized.count(NextBB)) {
       Stack.pop_back();
       continue;
     }
     LLVM_DEBUG(dbgs() << "  visiting " << CI.getSSAContext().print(NextBB)
while (!Stack.empty()) {
     }
   }
   LLVM_DEBUG(dbgs() << "exited computeStackPO\n");
 }
 
 template <typename ContextT>
 void ModifiedPostOrder<ContextT>::computeCyclePO(
     const CycleInfoT &CI, const CycleT *Cycle,
-    SmallPtrSetImpl<BlockT *> &Finalized) {
+    SmallPtrSetImpl<const BlockT *> &Finalized) {
   LLVM_DEBUG(dbgs() << "inside computeCyclePO\n");
-  SmallVector<BlockT *> Stack;
+  SmallVector<const BlockT *> Stack;
   auto *CycleHeader = Cycle->getHeader();
 
   LLVM_DEBUG(dbgs() << "  noted header: "
                     << CI.getSSAContext().print(CycleHeader) << "\n");
   assert(!Finalized.count(CycleHeader));
   Finalized.insert(CycleHeader);
 
   // Visit the header last
void ModifiedPostOrder<ContextT>::computeCyclePO(
   computeStackPO(Stack, CI, Cycle, Finalized);
 
   LLVM_DEBUG(dbgs() << "exited computeCyclePO\n");
 }
 
 /// \brief Generically compute the modified post order.
 template <typename ContextT>
 void llvm::ModifiedPostOrder<ContextT>::compute(const CycleInfoT &CI) {
-  SmallPtrSet<BlockT *, 32> Finalized;
-  SmallVector<BlockT *> Stack;
+  SmallPtrSet<const BlockT *, 32> Finalized;
+  SmallVector<const BlockT *> Stack;
   auto *F = CI.getFunction();
   Stack.reserve(24); // FIXME made-up number
-  Stack.push_back(GraphTraits<FunctionT *>::getEntryNode(F));
+  Stack.push_back(&F->front());
   computeStackPO(Stack, CI, nullptr, Finalized);
 }
 
 } // namespace llvm
 
 #undef DEBUG_TYPE
 
 #endif // LLVM_ADT_GENERICUNIFORMITYIMPL_H

llvm/include/llvm/ADT/GenericUniformityInfo.h

public:
   using UseT = typename ContextT::UseT;
   using InstructionT = typename ContextT::InstructionT;
   using DominatorTreeT = typename ContextT::DominatorTreeT;
   using ThisT = GenericUniformityInfo<ContextT>;
 
   using CycleInfoT = GenericCycleInfo<ContextT>;
   using CycleT = typename CycleInfoT::CycleT;
 
-  GenericUniformityInfo(FunctionT &F, const DominatorTreeT &DT,
-                        const CycleInfoT &CI,
+  GenericUniformityInfo(const DominatorTreeT &DT, const CycleInfoT &CI,
                         const TargetTransformInfo *TTI = nullptr);
   GenericUniformityInfo() = default;
   GenericUniformityInfo(GenericUniformityInfo &&) = default;
   GenericUniformityInfo &operator=(GenericUniformityInfo &&) = default;
 
   void compute() {
     DA->initialize();
     DA->compute();
   }
 
   /// Whether any divergence was detected.
   bool hasDivergence() const;
 
   /// The GPU kernel this analysis result is for
-  const FunctionT &getFunction() const { return *F; }
+  const FunctionT &getFunction() const;
 
   /// Whether \p V is divergent at its definition.
   bool isDivergent(ConstValueRefT V) const;
 
   /// Whether \p V is uniform/non-divergent.
   bool isUniform(ConstValueRefT V) const { return !isDivergent(V); }
 
   // Similar queries for InstructionT. These accept a pointer argument so that
public:
 
   bool hasDivergentTerminator(const BlockT &B);
 
   void print(raw_ostream &Out) const;
 
 private:
   using ImplT = GenericUniformityAnalysisImpl<ContextT>;
 
-  FunctionT *F;
   std::unique_ptr<ImplT, GenericUniformityAnalysisImplDeleter<ImplT>> DA;
 
   GenericUniformityInfo(const GenericUniformityInfo &) = delete;
   GenericUniformityInfo &operator=(const GenericUniformityInfo &) = delete;
 };
 
 } // namespace llvm
 
 #endif // LLVM_ADT_GENERICUNIFORMITYINFO_H

llvm/include/llvm/CodeGen/MachineSSAContext.h

 /// This file declares a specialization of the GenericSSAContext<X>
 /// template class for Machine IR.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_MACHINESSACONTEXT_H
 #define LLVM_CODEGEN_MACHINESSACONTEXT_H
 
+#include "llvm/ADT/GenericSSAContext.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/Support/Printable.h"
 
 namespace llvm {
 class MachineRegisterInfo;
 class MachineInstr;
 class MachineFunction;
 class Register;
-template <typename _FunctionT> class GenericSSAContext;
-template <typename, bool> class DominatorTreeBase;
 
 inline unsigned succ_size(const MachineBasicBlock *BB) {
   return BB->succ_size();
 }
 inline unsigned pred_size(const MachineBasicBlock *BB) {
   return BB->pred_size();
 }
 inline auto instrs(const MachineBasicBlock &BB) { return BB.instrs(); }
 
-template <> class GenericSSAContext<MachineFunction> {
-  const MachineRegisterInfo *RegInfo = nullptr;
-  MachineFunction *MF = nullptr;
-
-public:
+template <> struct GenericSSATraits<MachineFunction> {
   using BlockT = MachineBasicBlock;
   using FunctionT = MachineFunction;
   using InstructionT = MachineInstr;
   using ValueRefT = Register;
   using ConstValueRefT = Register;
   using UseT = MachineOperand;
-  using DominatorTreeT = DominatorTreeBase<BlockT, false>;
-
-  static constexpr Register ValueRefNull = 0;
-
-  void setFunction(MachineFunction &Fn);
-  MachineFunction *getFunction() const { return MF; }
-
-  static MachineBasicBlock *getEntryBlock(MachineFunction &F);
-  static void appendBlockDefs(SmallVectorImpl<Register> &defs,
-                              const MachineBasicBlock &block);
-  static void appendBlockTerms(SmallVectorImpl<MachineInstr *> &terms,
-                               MachineBasicBlock &block);
-  static void appendBlockTerms(SmallVectorImpl<const MachineInstr *> &terms,
-                               const MachineBasicBlock &block);
-  MachineBasicBlock *getDefBlock(Register) const;
-  static bool isConstantOrUndefValuePhi(const MachineInstr &Phi);
-
-  Printable print(const MachineBasicBlock *Block) const;
-  Printable print(const MachineInstr *Inst) const;
-  Printable print(Register Value) const;
 };
 
 using MachineSSAContext = GenericSSAContext<MachineFunction>;
 } // namespace llvm
 
 #endif // LLVM_CODEGEN_MACHINESSACONTEXT_H

llvm/include/llvm/IR/SSAContext.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_SSACONTEXT_H
 #define LLVM_IR_SSACONTEXT_H
 
 #include "llvm/ADT/GenericSSAContext.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/ModuleSlotTracker.h"
-#include "llvm/Support/Printable.h"
-
-#include <memory>
 
 namespace llvm {
 class BasicBlock;
 class Function;
 class Instruction;
 class Value;
-template <typename> class SmallVectorImpl;
-template <typename, bool> class DominatorTreeBase;
 
 inline auto instrs(const BasicBlock &BB) {
   return llvm::make_range(BB.begin(), BB.end());
 }
 
-template <> class GenericSSAContext<Function> {
-  Function *F;
-
-public:
+template <> struct GenericSSATraits<Function> {
   using BlockT = BasicBlock;
   using FunctionT = Function;
   using InstructionT = Instruction;
   using ValueRefT = Value *;
   using ConstValueRefT = const Value *;
   using UseT = Use;
-  using DominatorTreeT = DominatorTreeBase<BlockT, false>;
-
-  static constexpr Value *ValueRefNull = nullptr;
-
-  void setFunction(Function &Fn);
-  Function *getFunction() const { return F; }
-
-  static BasicBlock *getEntryBlock(Function &F);
-  static const BasicBlock *getEntryBlock(const Function &F);
-
-  static void appendBlockDefs(SmallVectorImpl<Value *> &defs,
-                              BasicBlock &block);
-  static void appendBlockDefs(SmallVectorImpl<const Value *> &defs,
-                              const BasicBlock &block);
-
-  static void appendBlockTerms(SmallVectorImpl<Instruction *> &terms,
-                               BasicBlock &block);
-  static void appendBlockTerms(SmallVectorImpl<const Instruction *> &terms,
-                               const BasicBlock &block);
-
-  static bool comesBefore(const Instruction *lhs, const Instruction *rhs);
-  static bool isConstantOrUndefValuePhi(const Instruction &Instr);
-  const BasicBlock *getDefBlock(const Value *value) const;
-
-  Printable print(const BasicBlock *Block) const;
-  Printable print(const Instruction *Inst) const;
-  Printable print(const Value *Value) const;
 };
 
 using SSAContext = GenericSSAContext<Function>;
 
 } // namespace llvm
 
 #endif // LLVM_IR_SSACONTEXT_H

llvm/lib/Analysis/UniformityAnalysis.cpp

 //  UniformityInfoAnalysis and related pass implementations
 //===----------------------------------------------------------------------===//
 
 llvm::UniformityInfo UniformityInfoAnalysis::run(Function &F,
                                                  FunctionAnalysisManager &FAM) {
   auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
   auto &TTI = FAM.getResult<TargetIRAnalysis>(F);
   auto &CI = FAM.getResult<CycleAnalysis>(F);
-  UniformityInfo UI{F, DT, CI, &TTI};
+  UniformityInfo UI{DT, CI, &TTI};
   // Skip computation if we can assume everything is uniform.
   if (TTI.hasBranchDivergence(&F))
     UI.compute();
 
   return UI;
 }
 
 AnalysisKey UniformityInfoAnalysis::Key;

 
 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{F, domTree, cycleInfo, &targetTransformInfo};
+  m_uniformityInfo = UniformityInfo{domTree, cycleInfo, &targetTransformInfo};
 
   // Skip computation if we can assume everything is uniform.
   if (targetTransformInfo.hasBranchDivergence(m_function))
     m_uniformityInfo.compute();
 
   return false;
 }
 
 void UniformityInfoWrapperPass::print(raw_ostream &OS, const Module *) const {
   OS << "UniformityInfo for function '" << m_function->getName() << "':\n";
 }
 
 void UniformityInfoWrapperPass::releaseMemory() {
   m_uniformityInfo = UniformityInfo{};
   m_function = nullptr;
 }

llvm/lib/CodeGen/MachineSSAContext.cpp

 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
-void MachineSSAContext::setFunction(MachineFunction &Fn) {
-  MF = &Fn;
-  RegInfo = &MF->getRegInfo();
+template <>
+void MachineSSAContext::appendBlockDefs(SmallVectorImpl<Register> &defs,
+                                        const MachineBasicBlock &block) {
+  for (auto &instr : block.instrs()) {
+    for (auto &op : instr.all_defs())
+      defs.push_back(op.getReg());
+  }
 }
 
-MachineBasicBlock *MachineSSAContext::getEntryBlock(MachineFunction &F) {
-  return &F.front();
+template <>
+void MachineSSAContext::appendBlockTerms(SmallVectorImpl<MachineInstr *> &terms,
+                                         MachineBasicBlock &block) {
+  for (auto &T : block.terminators())
+    terms.push_back(&T);
 }
 
+template <>
 void MachineSSAContext::appendBlockTerms(
     SmallVectorImpl<const MachineInstr *> &terms,
     const MachineBasicBlock &block) {
   for (auto &T : block.terminators())
     terms.push_back(&T);
 }
 
-void MachineSSAContext::appendBlockDefs(SmallVectorImpl<Register> &defs,
-                                        const MachineBasicBlock &block) {
-  for (const MachineInstr &instr : block.instrs()) {
-    for (const MachineOperand &op : instr.all_defs())
-      defs.push_back(op.getReg());
-  }
-}
-
 /// Get the defining block of a value.
-MachineBasicBlock *MachineSSAContext::getDefBlock(Register value) const {
+template <>
+const MachineBasicBlock *MachineSSAContext::getDefBlock(Register value) const {
   if (!value)
     return nullptr;
-  return RegInfo->getVRegDef(value)->getParent();
+  return F->getRegInfo().getVRegDef(value)->getParent();
 }
 
+template <>
 bool MachineSSAContext::isConstantOrUndefValuePhi(const MachineInstr &Phi) {
   return Phi.isConstantValuePHI();
 }
 
+template <>
 Printable MachineSSAContext::print(const MachineBasicBlock *Block) const {
   if (!Block)
     return Printable([](raw_ostream &Out) { Out << "<nullptr>"; });
   return Printable([Block](raw_ostream &Out) { Block->printName(Out); });
 }
 
-Printable MachineSSAContext::print(const MachineInstr *I) const {
+template <> Printable MachineSSAContext::print(const MachineInstr *I) const {
   return Printable([I](raw_ostream &Out) { I->print(Out); });
 }
 
-Printable MachineSSAContext::print(Register Value) const {
-  auto *MRI = RegInfo;
+template <> Printable MachineSSAContext::print(Register Value) const {
+  auto *MRI = &F->getRegInfo();
   return Printable([MRI, Value](raw_ostream &Out) {
     Out << printReg(Value, MRI->getTargetRegisterInfo(), 0, MRI);
 
     if (Value) {
       // Try to print the definition.
       if (auto *Instr = MRI->getUniqueVRegDef(Value)) {
         Out << ": ";
         Instr->print(Out);
       }
     }
   });
 }

llvm/lib/CodeGen/MachineUniformityAnalysis.cpp

 template class llvm::GenericUniformityInfo<MachineSSAContext>;
 template struct llvm::GenericUniformityAnalysisImplDeleter<
     llvm::GenericUniformityAnalysisImpl<MachineSSAContext>>;
 
 MachineUniformityInfo llvm::computeMachineUniformityInfo(
     MachineFunction &F, const MachineCycleInfo &cycleInfo,
     const MachineDomTree &domTree, bool HasBranchDivergence) {
   assert(F.getRegInfo().isSSA() && "Expected to be run on SSA form!");
-  MachineUniformityInfo UI(F, domTree, cycleInfo);
+  MachineUniformityInfo UI(domTree, cycleInfo);
   if (HasBranchDivergence)
     UI.compute();
   return UI;
 }
 
 namespace {
 
 /// Legacy analysis pass which computes a \ref MachineUniformityInfo.

llvm/lib/IR/SSAContext.cpp

 
 #include "llvm/IR/SSAContext.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/IR/ModuleSlotTracker.h"
 
 using namespace llvm;
 
-void SSAContext::setFunction(Function &Fn) { F = &Fn; }
-
-BasicBlock *SSAContext::getEntryBlock(Function &F) {
-  return &F.getEntryBlock();
-}
-
-const BasicBlock *SSAContext::getEntryBlock(const Function &F) {
-  return &F.getEntryBlock();
-}
-
+template <>
 void SSAContext::appendBlockDefs(SmallVectorImpl<Value *> &defs,
                                  BasicBlock &block) {
-  for (auto &instr : block.instructionsWithoutDebug(/*SkipPseudoOp=*/true)) {
+  for (auto &instr : block) {
     if (instr.isTerminator())
       break;
-    if (instr.getType()->isVoidTy())
-      continue;
-    auto *def = &instr;
-    defs.push_back(def);
+    defs.push_back(&instr);
   }
 }
 
+template <>
 void SSAContext::appendBlockDefs(SmallVectorImpl<const Value *> &defs,
                                  const BasicBlock &block) {
   for (auto &instr : block) {
     if (instr.isTerminator())
       break;
     defs.push_back(&instr);
   }
 }
 
+template <>
 void SSAContext::appendBlockTerms(SmallVectorImpl<Instruction *> &terms,
                                   BasicBlock &block) {
   terms.push_back(block.getTerminator());
 }
 
+template <>
 void SSAContext::appendBlockTerms(SmallVectorImpl<const Instruction *> &terms,
                                   const BasicBlock &block) {
   terms.push_back(block.getTerminator());
 }
 
+template <>
 const BasicBlock *SSAContext::getDefBlock(const Value *value) const {
   if (const auto *instruction = dyn_cast<Instruction>(value))
     return instruction->getParent();
   return nullptr;
 }
 
-bool SSAContext::comesBefore(const Instruction *lhs, const Instruction *rhs) {
-  return lhs->comesBefore(rhs);
-}
-
+template <>
 bool SSAContext::isConstantOrUndefValuePhi(const Instruction &Instr) {
   if (auto *Phi = dyn_cast<PHINode>(&Instr))
     return Phi->hasConstantOrUndefValue();
   return false;
 }
 
-Printable SSAContext::print(const Value *V) const {
+template <> Printable SSAContext::print(const Value *V) const {
   return Printable([V](raw_ostream &Out) { V->print(Out); });
 }
 
-Printable SSAContext::print(const Instruction *Inst) const {
+template <> Printable SSAContext::print(const Instruction *Inst) const {
   return print(cast<Value>(Inst));
 }
 
-Printable SSAContext::print(const BasicBlock *BB) const {
+template <> Printable SSAContext::print(const BasicBlock *BB) const {
   if (!BB)
     return Printable([](raw_ostream &Out) { Out << "<nullptr>"; });
   if (BB->hasName())
     return Printable([BB](raw_ostream &Out) { Out << BB->getName(); });
 
   return Printable([BB](raw_ostream &Out) {
     ModuleSlotTracker MST{BB->getParent()->getParent(), false};
     MST.incorporateFunction(*BB->getParent());
     Out << MST.getLocalSlot(BB);
   });
 }