[llvm] r293459 - [LoopVectorize] Improve getVectorCallCost() getScalarizationOverhead() call.

[Jonas Paulsson via llvm-commits]

Author: jonpa
Date: Sun Jan 29 23:38:05 2017
New Revision: 293459

URL: http://llvm.org/viewvc/llvm-project?rev=293459&view=rev
Log:
[LoopVectorize] Improve getVectorCallCost() getScalarizationOverhead() call.

By calling getScalarizationOverhead with the CallInst instead of the types of
its arguments, we make sure that only unique call arguments are added to the
scalarization cost.

getScalarizationOverhead() is extended to handle calls by only passing on the
actual call arguments (which is not all the operands).

This also eliminates a wrapper function with the same name.

review: Hal Finkel

Modified:
    llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp

Modified: llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp?rev=293459&r1=293458&r2=293459&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp (original)
+++ llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp Sun Jan 29 23:38:05 2017
@@ -3598,22 +3598,6 @@ static Value *addFastMathFlag(Value *V)
   return V;
 }
 
-/// \brief Estimate the overhead of scalarizing an Instruction based on the
-/// types of its operands and return value.
-static unsigned getScalarizationOverhead(SmallVectorImpl<Type *> &OpTys,
-                                         Type *RetTy,
-                                         const TargetTransformInfo &TTI) {
-  unsigned ScalarizationCost = 0;
-
-  if (!RetTy->isVoidTy())
-    ScalarizationCost += TTI.getScalarizationOverhead(RetTy, true, false);
-
-  for (Type *Ty : OpTys)
-    ScalarizationCost += TTI.getScalarizationOverhead(Ty, false, true);
-
-  return ScalarizationCost;
-}
-
 /// \brief Estimate the overhead of scalarizing an instruction. This is a
 /// convenience wrapper for the type-based getScalarizationOverhead API.
 static unsigned getScalarizationOverhead(Instruction *I, unsigned VF,
@@ -3626,8 +3610,13 @@ static unsigned getScalarizationOverhead
   if (!RetTy->isVoidTy())
     Cost += TTI.getScalarizationOverhead(RetTy, true, false);
 
-  SmallVector<const Value *, 4> Operands(I->operand_values());
-  Cost += TTI.getOperandsScalarizationOverhead(Operands, VF);
+  if (CallInst *CI = dyn_cast<CallInst>(I)) {
+    SmallVector<const Value *, 4> Operands(CI->arg_operands());
+    Cost += TTI.getOperandsScalarizationOverhead(Operands, VF);
+  } else {
+    SmallVector<const Value *, 4> Operands(I->operand_values());
+    Cost += TTI.getOperandsScalarizationOverhead(Operands, VF);
+  }
 
   return Cost;
 }
@@ -3662,7 +3651,7 @@ static unsigned getVectorCallCost(CallIn
 
   // Compute costs of unpacking argument values for the scalar calls and
   // packing the return values to a vector.
-  unsigned ScalarizationCost = getScalarizationOverhead(Tys, RetTy, TTI);
+  unsigned ScalarizationCost = getScalarizationOverhead(CI, VF, TTI);
 
   unsigned Cost = ScalarCallCost * VF + ScalarizationCost;