From 54490fc7caf3354934dc73321e0bbe1d17df7d4f Mon Sep 17 00:00:00 2001 From: Jonas Paulsson Date: Mon, 30 Jan 2017 05:38:05 +0000 Subject: [PATCH] [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 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@293459 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Vectorize/LoopVectorize.cpp | 27 +++++++--------------- 1 file changed, 8 insertions(+), 19 deletions(-) diff --git a/lib/Transforms/Vectorize/LoopVectorize.cpp b/lib/Transforms/Vectorize/LoopVectorize.cpp index 4c2de937aab..4645714faeb 100644 --- a/lib/Transforms/Vectorize/LoopVectorize.cpp +++ b/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -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 &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(Instruction *I, unsigned VF, if (!RetTy->isVoidTy()) Cost += TTI.getScalarizationOverhead(RetTy, true, false); - SmallVector Operands(I->operand_values()); - Cost += TTI.getOperandsScalarizationOverhead(Operands, VF); + if (CallInst *CI = dyn_cast(I)) { + SmallVector Operands(CI->arg_operands()); + Cost += TTI.getOperandsScalarizationOverhead(Operands, VF); + } else { + SmallVector Operands(I->operand_values()); + Cost += TTI.getOperandsScalarizationOverhead(Operands, VF); + } return Cost; } @@ -3662,7 +3651,7 @@ static unsigned getVectorCallCost(CallInst *CI, unsigned VF, // 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; -- 2.50.1