[SLP] Pass full scalar and vector context instructions to TTI.

[fhahn]

Summary

Depends on D132966.

[ABataev]

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

6441–6444

Use range-based loop

6463–6464

for (Value *V : VL.drop_front())
  OpsForVector.push_back(cast<Instruction>(V));

or some magic cast using llvm::copy

[fhahn]

Address latest comments, thanks!

[fhahn]

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

6441–6444

Thanks should be fixed!

6463–6464

Thanks, updated to a range-based for loop.

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

case Instruction::Xor: {
       TTI::OperandValueInfo Op1Info = {TTI::OK_AnyValue, TTI::OP_None};
 
       // Certain instructions can be cheaper to vectorize if they have a
       // constant second vector operand.
       const unsigned OpIdx = isa<BinaryOperator>(VL0) ? 1 : 0;
       auto Op2Info = getOperandInfo(VL, OpIdx);
 
       SmallVector<const Value *, 4> Operands(VL0->operand_values());
-      InstructionCost ScalarEltCost =
-          TTI->getArithmeticInstrCost(E->getOpcode(), ScalarTy, CostKind,
-                                      Op1Info, Op2Info,
-                                      Operands, VL0);
+      InstructionCost ScalarCost = 0;
+      for (const Value *V : VL) {
+        ScalarCost += TTI->getArithmeticInstrCost(
+            E->getOpcode(), ScalarTy, CostKind, Op1Info, Op2Info, Operands,
+            isa<Instruction>(V) ? cast<Instruction>(V) : nullptr);
+      }
+
       if (NeedToShuffleReuses) {
-        CommonCost -= (EntryVF - VL.size()) * ScalarEltCost;
+        CommonCost -=
+            (EntryVF - VL.size()) *
+            TTI->getArithmeticInstrCost(E->getOpcode(), ScalarTy, CostKind,
+                                        Op1Info, Op2Info, Operands);
       }
-      InstructionCost ScalarCost = VecTy->getNumElements() * ScalarEltCost;
+
       for (unsigned I = 0, Num = VL0->getNumOperands(); I < Num; ++I) {
         if (all_of(VL, [I](Value *V) {
               return isConstant(cast<Instruction>(V)->getOperand(I));
             }))
           Operands[I] = ConstantVector::getNullValue(VecTy);
       }
+
+      // Populate vector with context instructions.
+      SmallVector<const Instruction *> OpsForVector = {VL0};
+      for (const Value *V : VL.drop_front())
+        OpsForVector.push_back(cast<Instruction>(V));
+
       InstructionCost VecCost =
-          TTI->getArithmeticInstrCost(E->getOpcode(), VecTy, CostKind,
-                                      Op1Info, Op2Info,
-                                      Operands, VL0);
+          TTI->getArithmeticInstrCost(E->getOpcode(), VecTy, CostKind, Op1Info,
+                                      Op2Info, Operands, OpsForVector);
+
       LLVM_DEBUG(dumpTreeCosts(E, CommonCost, VecCost, ScalarCost));
       return CommonCost + VecCost - ScalarCost;
     }
     case Instruction::GetElementPtr: {
       TargetTransformInfo::OperandValueKind Op1VK =
           TargetTransformInfo::OK_AnyValue;
       TargetTransformInfo::OperandValueKind Op2VK =
           any_of(VL,