[SLP] Make HorizontalReduction::getOperationData take an Instruction* instead of a Value*. NFCI

[craig.topper]

Summary

All of the callers already have an Instruction *. Many of them
from a dyn_cast.

Also update the OperationData constructor to use a Instruction&
to remove a dyn_cast and make it clear that the pointer is non-null.

[RKSimon]

LGTM

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

Value *createOp(IRBuilder<> &Builder, const Twine &Name) const {
       llvm_unreachable("Unknown reduction operation.");
     }
 
   public:
     explicit OperationData() = default;
 
     /// Construction for reduced values. They are identified by opcode only and
     /// don't have associated LHS/RHS values.
-    explicit OperationData(Value *V) {
-      if (auto *I = dyn_cast<Instruction>(V))
-        Opcode = I->getOpcode();
+    explicit OperationData(Instruction &I) {
+      Opcode = I.getOpcode();
     }
 
     /// Constructor for reduction operations with opcode and its left and
     /// right operands.
     OperationData(unsigned Opcode, Value *LHS, Value *RHS, ReductionKind Kind)
         : Opcode(Opcode), LHS(LHS), RHS(RHS), Kind(Kind) {
       assert(Kind != RK_None && "One of the reduction operations is expected.");
     }
if (ExtraArgs.count(ParentStackElem.first)) {
       ParentStackElem.second = ParentStackElem.first->getNumOperands();
     } else {
       // We ran into something like:
       // ParentStackElem.first += ... + ExtraArg + ...
       ExtraArgs[ParentStackElem.first] = ExtraArg;
     }
   }
 
-  static OperationData getOperationData(Value *V) {
-    if (!V)
+  static OperationData getOperationData(Instruction *I) {
+    if (!I)
       return OperationData();
 
     Value *LHS;
     Value *RHS;
-    if (m_BinOp(m_Value(LHS), m_Value(RHS)).match(V)) {
-      return OperationData(cast<BinaryOperator>(V)->getOpcode(), LHS, RHS,
+    if (m_BinOp(m_Value(LHS), m_Value(RHS)).match(I)) {
+      return OperationData(cast<BinaryOperator>(I)->getOpcode(), LHS, RHS,
                            RK_Arithmetic);
     }
-    if (auto *Select = dyn_cast<SelectInst>(V)) {
+    if (auto *Select = dyn_cast<SelectInst>(I)) {
       // Look for a min/max pattern.
       if (m_UMin(m_Value(LHS), m_Value(RHS)).match(Select)) {
         return OperationData(Instruction::ICmp, LHS, RHS, RK_UMin);
       } else if (m_SMin(m_Value(LHS), m_Value(RHS)).match(Select)) {
         return OperationData(Instruction::ICmp, LHS, RHS, RK_SMin);
       } else if (m_UMax(m_Value(LHS), m_Value(RHS)).match(Select)) {
         return OperationData(Instruction::ICmp, LHS, RHS, RK_UMax);
       } else if (m_SMax(m_Value(LHS), m_Value(RHS)).match(Select)) {
if (auto *Select = dyn_cast<SelectInst>(I)) {
         LHS = Select->getTrueValue();
         RHS = Select->getFalseValue();
         Value *Cond = Select->getCondition();
 
         // TODO: Support inverse predicates.
         if (match(Cond, m_Cmp(Pred, m_Specific(LHS), m_Instruction(L2)))) {
           if (!isa<ExtractElementInst>(RHS) ||
               !L2->isIdenticalTo(cast<Instruction>(RHS)))
-            return OperationData(V);
+            return OperationData(*I);
         } else if (match(Cond, m_Cmp(Pred, m_Instruction(L1), m_Specific(RHS)))) {
           if (!isa<ExtractElementInst>(LHS) ||
               !L1->isIdenticalTo(cast<Instruction>(LHS)))
-            return OperationData(V);
+            return OperationData(*I);
         } else {
           if (!isa<ExtractElementInst>(LHS) || !isa<ExtractElementInst>(RHS))
-            return OperationData(V);
+            return OperationData(*I);
           if (!match(Cond, m_Cmp(Pred, m_Instruction(L1), m_Instruction(L2))) ||
               !L1->isIdenticalTo(cast<Instruction>(LHS)) ||
               !L2->isIdenticalTo(cast<Instruction>(RHS)))
-            return OperationData(V);
+            return OperationData(*I);
         }
         switch (Pred) {
         default:
-          return OperationData(V);
+          return OperationData(*I);
 
         case CmpInst::ICMP_ULT:
         case CmpInst::ICMP_ULE:
           return OperationData(Instruction::ICmp, LHS, RHS, RK_UMin);
 
         case CmpInst::ICMP_SLT:
         case CmpInst::ICMP_SLE:
           return OperationData(Instruction::ICmp, LHS, RHS, RK_SMin);
 
         case CmpInst::ICMP_UGT:
         case CmpInst::ICMP_UGE:
           return OperationData(Instruction::ICmp, LHS, RHS, RK_UMax);
 
         case CmpInst::ICMP_SGT:
         case CmpInst::ICMP_SGE:
           return OperationData(Instruction::ICmp, LHS, RHS, RK_SMax);
         }
       }
     }
-    return OperationData(V);
+    return OperationData(*I);
   }
 
 public:
   HorizontalReduction() = default;
 
   /// Try to find a reduction tree.
   bool matchAssociativeReduction(PHINode *Phi, Instruction *B) {
     assert((!Phi || is_contained(Phi->operands(), B)) &&