[llvm][Uniformity] provide overloads for Instruction* and Value*

[sameerds]

Summary

Uniformity analysis is mainly concerned with the uniformity of values. But it is
sometimes useful to ask if an instruction is uniform, for example, if the
instruction is a terminator. On LLVM IR, every Instruction is a Value, so the
queries like isUniform() need to be overloaded so that the most derived class
always wins.

[ruiling]

Thank you for the fix! LGTM

[foad]

I'm fine with the patch but I don't particularly like the fact that DA has an isDivergent(Instruction *) in the first place, because it's really unclear what it means - for non-void instructions I guess it's the same as isDivergent(Value *), and for conditional branches it means something specific, and for other instructions...? I'd much prefer for have a more specific isDivergentBranch(BranchInst *).

llvm/include/llvm/ADT/GenericUniformityImpl.h

 
 /// 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 {
+  return DA->isDivergent(*I);
+}
+
+template <typename ContextT>
 bool GenericUniformityInfo<ContextT>::hasDivergentTerminator(const BlockT &B) {
   return DA->hasDivergentTerminator(B);
 }
 
 /// \brief T helper function for printing.
 template <typename ContextT>
 void GenericUniformityInfo<ContextT>::print(raw_ostream &out) const {
   DA->print(out);

llvm/include/llvm/ADT/GenericUniformityInfo.h

public:
   const FunctionT &getFunction() const { return *F; }
 
   /// 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
+  // in LLVM IR, they overload the equivalent queries for Value*. For example,
+  // if querying whether a BranchInst is divergent, it should not be treated as
+  // a Value in LLVM IR.
+  bool isUniform(const InstructionT *I) const { return !isDivergent(I); };
+  bool isDivergent(const InstructionT *I) const;
+
   bool hasDivergentTerminator(const BlockT &B);
 
   void print(raw_ostream &Out) const;
 
 private:
   using ImplT = GenericUniformityAnalysisImpl<ContextT>;
 
   FunctionT *F;