mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-01-31 12:41:49 +01:00
[Analysis] Add simple cost model for strict (in-order) reductions
I have added a new FastMathFlags parameter to getArithmeticReductionCost to indicate what type of reduction we are performing: 1. Tree-wise. This is the typical fast-math reduction that involves continually splitting a vector up into halves and adding each half together until we get a scalar result. This is the default behaviour for integers, whereas for floating point we only do this if reassociation is allowed. 2. Ordered. This now allows us to estimate the cost of performing a strict vector reduction by treating it as a series of scalar operations in lane order. This is the case when FP reassociation is not permitted. For scalable vectors this is more difficult because at compile time we do not know how many lanes there are, and so we use the worst case maximum vscale value. I have also fixed getTypeBasedIntrinsicInstrCost to pass in the FastMathFlags, which meant fixing up some X86 tests where we always assumed the vector.reduce.fadd/mul intrinsics were 'fast'. New tests have been added here: Analysis/CostModel/AArch64/reduce-fadd.ll Analysis/CostModel/AArch64/sve-intrinsics.ll Transforms/LoopVectorize/AArch64/strict-fadd-cost.ll Transforms/LoopVectorize/AArch64/sve-strict-fadd-cost.ll Differential Revision: https://reviews.llvm.org/D105432
This commit is contained in:
David Sherwood
parent
2df597c58a
commit
2d2e4a1b17
@ -1146,12 +1146,38 @@ public:
|
||||
TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput,
|
||||
bool UseMaskForCond = false, bool UseMaskForGaps = false) const;
|
||||
|
||||
/// A helper function to determine the type of reduction algorithm used
|
||||
/// for a given \p Opcode and set of FastMathFlags \p FMF.
|
||||
static bool requiresOrderedReduction(Optional<FastMathFlags> FMF) {
|
||||
return FMF != None && !(*FMF).allowReassoc();
|
||||
}
|
||||
|
||||
/// Calculate the cost of vector reduction intrinsics.
|
||||
///
|
||||
/// This is the cost of reducing the vector value of type \p Ty to a scalar
|
||||
/// value using the operation denoted by \p Opcode.
|
||||
/// value using the operation denoted by \p Opcode. The FastMathFlags
|
||||
/// parameter \p FMF indicates what type of reduction we are performing:
|
||||
/// 1. Tree-wise. This is the typical 'fast' reduction performed that
|
||||
/// involves successively splitting a vector into half and doing the
|
||||
/// operation on the pair of halves until you have a scalar value. For
|
||||
/// example:
|
||||
/// (v0, v1, v2, v3)
|
||||
/// ((v0+v2), (v1+v3), undef, undef)
|
||||
/// ((v0+v2+v1+v3), undef, undef, undef)
|
||||
/// This is the default behaviour for integer operations, whereas for
|
||||
/// floating point we only do this if \p FMF indicates that
|
||||
/// reassociation is allowed.
|
||||
/// 2. Ordered. For a vector with N elements this involves performing N
|
||||
/// operations in lane order, starting with an initial scalar value, i.e.
|
||||
/// result = InitVal + v0
|
||||
/// result = result + v1
|
||||
/// result = result + v2
|
||||
/// result = result + v3
|
||||
/// This is only the case for FP operations and when reassociation is not
|
||||
/// allowed.
|
||||
///
|
||||
InstructionCost getArithmeticReductionCost(
|
||||
unsigned Opcode, VectorType *Ty,
|
||||
unsigned Opcode, VectorType *Ty, Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput) const;
|
||||
|
||||
InstructionCost getMinMaxReductionCost(
|
||||
@ -1618,6 +1644,7 @@ public:
|
||||
bool UseMaskForCond = false, bool UseMaskForGaps = false) = 0;
|
||||
virtual InstructionCost
|
||||
getArithmeticReductionCost(unsigned Opcode, VectorType *Ty,
|
||||
Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind) = 0;
|
||||
virtual InstructionCost
|
||||
getMinMaxReductionCost(VectorType *Ty, VectorType *CondTy, bool IsUnsigned,
|
||||
@ -2119,8 +2146,9 @@ public:
|
||||
}
|
||||
InstructionCost
|
||||
getArithmeticReductionCost(unsigned Opcode, VectorType *Ty,
|
||||
Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind) override {
|
||||
return Impl.getArithmeticReductionCost(Opcode, Ty, CostKind);
|
||||
return Impl.getArithmeticReductionCost(Opcode, Ty, FMF, CostKind);
|
||||
}
|
||||
InstructionCost
|
||||
getMinMaxReductionCost(VectorType *Ty, VectorType *CondTy, bool IsUnsigned,
|
||||
|
||||
@ -622,6 +622,7 @@ public:
|
||||
}
|
||||
|
||||
InstructionCost getArithmeticReductionCost(unsigned, VectorType *,
|
||||
Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind) const {
|
||||
return 1;
|
||||
}
|
||||
|
||||
@ -1658,27 +1658,25 @@ public:
|
||||
}
|
||||
case Intrinsic::vector_reduce_add:
|
||||
return thisT()->getArithmeticReductionCost(Instruction::Add, VecOpTy,
|
||||
CostKind);
|
||||
None, CostKind);
|
||||
case Intrinsic::vector_reduce_mul:
|
||||
return thisT()->getArithmeticReductionCost(Instruction::Mul, VecOpTy,
|
||||
CostKind);
|
||||
None, CostKind);
|
||||
case Intrinsic::vector_reduce_and:
|
||||
return thisT()->getArithmeticReductionCost(Instruction::And, VecOpTy,
|
||||
CostKind);
|
||||
None, CostKind);
|
||||
case Intrinsic::vector_reduce_or:
|
||||
return thisT()->getArithmeticReductionCost(Instruction::Or, VecOpTy,
|
||||
return thisT()->getArithmeticReductionCost(Instruction::Or, VecOpTy, None,
|
||||
CostKind);
|
||||
case Intrinsic::vector_reduce_xor:
|
||||
return thisT()->getArithmeticReductionCost(Instruction::Xor, VecOpTy,
|
||||
CostKind);
|
||||
None, CostKind);
|
||||
case Intrinsic::vector_reduce_fadd:
|
||||
// FIXME: Add new flag for cost of strict reductions.
|
||||
return thisT()->getArithmeticReductionCost(Instruction::FAdd, VecOpTy,
|
||||
CostKind);
|
||||
FMF, CostKind);
|
||||
case Intrinsic::vector_reduce_fmul:
|
||||
// FIXME: Add new flag for cost of strict reductions.
|
||||
return thisT()->getArithmeticReductionCost(Instruction::FMul, VecOpTy,
|
||||
CostKind);
|
||||
FMF, CostKind);
|
||||
case Intrinsic::vector_reduce_smax:
|
||||
case Intrinsic::vector_reduce_smin:
|
||||
case Intrinsic::vector_reduce_fmax:
|
||||
@ -2014,8 +2012,8 @@ public:
|
||||
///
|
||||
/// The cost model should take into account that the actual length of the
|
||||
/// vector is reduced on each iteration.
|
||||
InstructionCost getArithmeticReductionCost(unsigned Opcode, VectorType *Ty,
|
||||
TTI::TargetCostKind CostKind) {
|
||||
InstructionCost getTreeReductionCost(unsigned Opcode, VectorType *Ty,
|
||||
TTI::TargetCostKind CostKind) {
|
||||
Type *ScalarTy = Ty->getElementType();
|
||||
unsigned NumVecElts = cast<FixedVectorType>(Ty)->getNumElements();
|
||||
if ((Opcode == Instruction::Or || Opcode == Instruction::And) &&
|
||||
@ -2067,6 +2065,47 @@ public:
|
||||
thisT()->getVectorInstrCost(Instruction::ExtractElement, Ty, 0);
|
||||
}
|
||||
|
||||
/// Try to calculate the cost of performing strict (in-order) reductions,
|
||||
/// which involves doing a sequence of floating point additions in lane
|
||||
/// order, starting with an initial value. For example, consider a scalar
|
||||
/// initial value 'InitVal' of type float and a vector of type <4 x float>:
|
||||
///
|
||||
/// Vector = <float %v0, float %v1, float %v2, float %v3>
|
||||
///
|
||||
/// %add1 = %InitVal + %v0
|
||||
/// %add2 = %add1 + %v1
|
||||
/// %add3 = %add2 + %v2
|
||||
/// %add4 = %add3 + %v3
|
||||
///
|
||||
/// As a simple estimate we can say the cost of such a reduction is 4 times
|
||||
/// the cost of a scalar FP addition. We can only estimate the costs for
|
||||
/// fixed-width vectors here because for scalable vectors we do not know the
|
||||
/// runtime number of operations.
|
||||
InstructionCost getOrderedReductionCost(unsigned Opcode, VectorType *Ty,
|
||||
TTI::TargetCostKind CostKind) {
|
||||
// Targets must implement a default value for the scalable case, since
|
||||
// we don't know how many lanes the vector has.
|
||||
if (isa<ScalableVectorType>(Ty))
|
||||
return InstructionCost::getInvalid();
|
||||
|
||||
auto *VTy = cast<FixedVectorType>(Ty);
|
||||
InstructionCost ExtractCost =
|
||||
getScalarizationOverhead(VTy, /*Insert=*/false, /*Extract=*/true);
|
||||
InstructionCost ArithCost =
|
||||
getArithmeticInstrCost(Opcode, VTy->getElementType(), CostKind);
|
||||
ArithCost *= VTy->getNumElements();
|
||||
|
||||
return ExtractCost + ArithCost;
|
||||
}
|
||||
|
||||
InstructionCost getArithmeticReductionCost(unsigned Opcode, VectorType *Ty,
|
||||
Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind) {
|
||||
if (TTI::requiresOrderedReduction(FMF))
|
||||
return getOrderedReductionCost(Opcode, Ty, CostKind);
|
||||
return getTreeReductionCost(Opcode, Ty, CostKind);
|
||||
}
|
||||
|
||||
/// Try to calculate op costs for min/max reduction operations.
|
||||
/// \param CondTy Conditional type for the Select instruction.
|
||||
InstructionCost getMinMaxReductionCost(VectorType *Ty, VectorType *CondTy,
|
||||
@ -2133,8 +2172,8 @@ public:
|
||||
// Without any native support, this is equivalent to the cost of
|
||||
// vecreduce.add(ext) or if IsMLA vecreduce.add(mul(ext, ext))
|
||||
VectorType *ExtTy = VectorType::get(ResTy, Ty);
|
||||
InstructionCost RedCost =
|
||||
thisT()->getArithmeticReductionCost(Instruction::Add, ExtTy, CostKind);
|
||||
InstructionCost RedCost = thisT()->getArithmeticReductionCost(
|
||||
Instruction::Add, ExtTy, None, CostKind);
|
||||
InstructionCost MulCost = 0;
|
||||
InstructionCost ExtCost = thisT()->getCastInstrCost(
|
||||
IsUnsigned ? Instruction::ZExt : Instruction::SExt, ExtTy, Ty,
|
||||
|
||||
@ -894,9 +894,10 @@ InstructionCost TargetTransformInfo::getMemcpyCost(const Instruction *I) const {
|
||||
}
|
||||
|
||||
InstructionCost TargetTransformInfo::getArithmeticReductionCost(
|
||||
unsigned Opcode, VectorType *Ty, TTI::TargetCostKind CostKind) const {
|
||||
unsigned Opcode, VectorType *Ty, Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind) const {
|
||||
InstructionCost Cost =
|
||||
TTIImpl->getArithmeticReductionCost(Opcode, Ty, CostKind);
|
||||
TTIImpl->getArithmeticReductionCost(Opcode, Ty, FMF, CostKind);
|
||||
assert(Cost >= 0 && "TTI should not produce negative costs!");
|
||||
return Cost;
|
||||
}
|
||||
|
||||
@ -1543,14 +1543,9 @@ InstructionCost AArch64TTIImpl::getGatherScatterOpCost(
|
||||
return InstructionCost::getInvalid();
|
||||
|
||||
ElementCount LegalVF = LT.second.getVectorElementCount();
|
||||
Optional<unsigned> MaxNumVScale = getMaxVScale();
|
||||
assert(MaxNumVScale && "Expected valid max vscale value");
|
||||
|
||||
InstructionCost MemOpCost =
|
||||
getMemoryOpCost(Opcode, VT->getElementType(), Alignment, 0, CostKind, I);
|
||||
unsigned MaxNumElementsPerGather =
|
||||
MaxNumVScale.getValue() * LegalVF.getKnownMinValue();
|
||||
return LT.first * MaxNumElementsPerGather * MemOpCost;
|
||||
return LT.first * MemOpCost * getMaxNumElements(LegalVF);
|
||||
}
|
||||
|
||||
bool AArch64TTIImpl::useNeonVector(const Type *Ty) const {
|
||||
@ -1956,7 +1951,22 @@ InstructionCost AArch64TTIImpl::getArithmeticReductionCostSVE(
|
||||
|
||||
InstructionCost
|
||||
AArch64TTIImpl::getArithmeticReductionCost(unsigned Opcode, VectorType *ValTy,
|
||||
Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind) {
|
||||
if (TTI::requiresOrderedReduction(FMF)) {
|
||||
if (!isa<ScalableVectorType>(ValTy))
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValTy, FMF, CostKind);
|
||||
|
||||
if (Opcode != Instruction::FAdd)
|
||||
return InstructionCost::getInvalid();
|
||||
|
||||
auto *VTy = cast<ScalableVectorType>(ValTy);
|
||||
InstructionCost Cost =
|
||||
getArithmeticInstrCost(Opcode, VTy->getScalarType(), CostKind);
|
||||
Cost *= getMaxNumElements(VTy->getElementCount());
|
||||
return Cost;
|
||||
}
|
||||
|
||||
if (isa<ScalableVectorType>(ValTy))
|
||||
return getArithmeticReductionCostSVE(Opcode, ValTy, CostKind);
|
||||
|
||||
@ -2031,7 +2041,7 @@ AArch64TTIImpl::getArithmeticReductionCost(unsigned Opcode, VectorType *ValTy,
|
||||
}
|
||||
break;
|
||||
}
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValTy, CostKind);
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValTy, FMF, CostKind);
|
||||
}
|
||||
|
||||
InstructionCost AArch64TTIImpl::getSpliceCost(VectorType *Tp, int Index) {
|
||||
|
||||
@ -131,6 +131,18 @@ public:
|
||||
return BaseT::getMaxVScale();
|
||||
}
|
||||
|
||||
/// Try to return an estimate cost factor that can be used as a multiplier
|
||||
/// when scalarizing an operation for a vector with ElementCount \p VF.
|
||||
/// For scalable vectors this currently takes the most pessimistic view based
|
||||
/// upon the maximum possible value for vscale.
|
||||
unsigned getMaxNumElements(ElementCount VF) const {
|
||||
if (!VF.isScalable())
|
||||
return VF.getFixedValue();
|
||||
Optional<unsigned> MaxNumVScale = getMaxVScale();
|
||||
assert(MaxNumVScale && "Expected valid max vscale value");
|
||||
return *MaxNumVScale * VF.getKnownMinValue();
|
||||
}
|
||||
|
||||
unsigned getMaxInterleaveFactor(unsigned VF);
|
||||
|
||||
InstructionCost getMaskedMemoryOpCost(unsigned Opcode, Type *Src,
|
||||
@ -305,7 +317,7 @@ public:
|
||||
ElementCount VF) const;
|
||||
|
||||
InstructionCost getArithmeticReductionCost(
|
||||
unsigned Opcode, VectorType *Ty,
|
||||
unsigned Opcode, VectorType *Ty, Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput);
|
||||
|
||||
InstructionCost getShuffleCost(TTI::ShuffleKind Kind, VectorType *Tp,
|
||||
|
||||
@ -843,13 +843,17 @@ InstructionCost GCNTTIImpl::getCFInstrCost(unsigned Opcode,
|
||||
|
||||
InstructionCost
|
||||
GCNTTIImpl::getArithmeticReductionCost(unsigned Opcode, VectorType *Ty,
|
||||
Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind) {
|
||||
if (TTI::requiresOrderedReduction(FMF))
|
||||
return BaseT::getArithmeticReductionCost(Opcode, Ty, FMF, CostKind);
|
||||
|
||||
EVT OrigTy = TLI->getValueType(DL, Ty);
|
||||
|
||||
// Computes cost on targets that have packed math instructions(which support
|
||||
// 16-bit types only).
|
||||
if (!ST->hasVOP3PInsts() || OrigTy.getScalarSizeInBits() != 16)
|
||||
return BaseT::getArithmeticReductionCost(Opcode, Ty, CostKind);
|
||||
return BaseT::getArithmeticReductionCost(Opcode, Ty, FMF, CostKind);
|
||||
|
||||
std::pair<InstructionCost, MVT> LT = TLI->getTypeLegalizationCost(DL, Ty);
|
||||
return LT.first * getFullRateInstrCost();
|
||||
|
||||
@ -212,7 +212,7 @@ public:
|
||||
int getInlinerVectorBonusPercent() { return 0; }
|
||||
|
||||
InstructionCost getArithmeticReductionCost(
|
||||
unsigned Opcode, VectorType *Ty,
|
||||
unsigned Opcode, VectorType *Ty, Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput);
|
||||
|
||||
InstructionCost getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
|
||||
|
||||
@ -1594,11 +1594,15 @@ InstructionCost ARMTTIImpl::getGatherScatterOpCost(
|
||||
|
||||
InstructionCost
|
||||
ARMTTIImpl::getArithmeticReductionCost(unsigned Opcode, VectorType *ValTy,
|
||||
Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind) {
|
||||
if (TTI::requiresOrderedReduction(FMF))
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValTy, FMF, CostKind);
|
||||
|
||||
EVT ValVT = TLI->getValueType(DL, ValTy);
|
||||
int ISD = TLI->InstructionOpcodeToISD(Opcode);
|
||||
if (!ST->hasMVEIntegerOps() || !ValVT.isSimple() || ISD != ISD::ADD)
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValTy, CostKind);
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValTy, FMF, CostKind);
|
||||
|
||||
std::pair<InstructionCost, MVT> LT = TLI->getTypeLegalizationCost(DL, ValTy);
|
||||
|
||||
@ -1610,7 +1614,7 @@ ARMTTIImpl::getArithmeticReductionCost(unsigned Opcode, VectorType *ValTy,
|
||||
if (const auto *Entry = CostTableLookup(CostTblAdd, ISD, LT.second))
|
||||
return Entry->Cost * ST->getMVEVectorCostFactor(CostKind) * LT.first;
|
||||
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValTy, CostKind);
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValTy, FMF, CostKind);
|
||||
}
|
||||
|
||||
InstructionCost
|
||||
|
||||
@ -257,6 +257,7 @@ public:
|
||||
const Instruction *I = nullptr);
|
||||
|
||||
InstructionCost getArithmeticReductionCost(unsigned Opcode, VectorType *ValTy,
|
||||
Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind);
|
||||
InstructionCost getExtendedAddReductionCost(bool IsMLA, bool IsUnsigned,
|
||||
Type *ResTy, VectorType *ValTy,
|
||||
|
||||
@ -3746,7 +3746,11 @@ InstructionCost X86TTIImpl::getAddressComputationCost(Type *Ty,
|
||||
|
||||
InstructionCost
|
||||
X86TTIImpl::getArithmeticReductionCost(unsigned Opcode, VectorType *ValTy,
|
||||
Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind) {
|
||||
if (TTI::requiresOrderedReduction(FMF))
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValTy, FMF, CostKind);
|
||||
|
||||
// We use the Intel Architecture Code Analyzer(IACA) to measure the throughput
|
||||
// and make it as the cost.
|
||||
|
||||
@ -3817,7 +3821,7 @@ X86TTIImpl::getArithmeticReductionCost(unsigned Opcode, VectorType *ValTy,
|
||||
return getCastInstrCost(Instruction::ZExt, WideVecTy, ValTy,
|
||||
TargetTransformInfo::CastContextHint::None,
|
||||
CostKind) +
|
||||
getArithmeticReductionCost(Opcode, WideVecTy, CostKind);
|
||||
getArithmeticReductionCost(Opcode, WideVecTy, FMF, CostKind);
|
||||
}
|
||||
|
||||
InstructionCost ArithmeticCost = 0;
|
||||
@ -3913,7 +3917,7 @@ X86TTIImpl::getArithmeticReductionCost(unsigned Opcode, VectorType *ValTy,
|
||||
if (const auto *Entry = CostTableLookup(SSE2BoolReduction, ISD, MTy))
|
||||
return ArithmeticCost + Entry->Cost;
|
||||
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValVTy, CostKind);
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValVTy, FMF, CostKind);
|
||||
}
|
||||
|
||||
unsigned NumVecElts = ValVTy->getNumElements();
|
||||
@ -3922,7 +3926,7 @@ X86TTIImpl::getArithmeticReductionCost(unsigned Opcode, VectorType *ValTy,
|
||||
// Special case power of 2 reductions where the scalar type isn't changed
|
||||
// by type legalization.
|
||||
if (!isPowerOf2_32(NumVecElts) || ScalarSize != MTy.getScalarSizeInBits())
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValVTy, CostKind);
|
||||
return BaseT::getArithmeticReductionCost(Opcode, ValVTy, FMF, CostKind);
|
||||
|
||||
InstructionCost ReductionCost = 0;
|
||||
|
||||
|
||||
@ -181,7 +181,7 @@ public:
|
||||
TTI::TargetCostKind CostKind);
|
||||
|
||||
InstructionCost getArithmeticReductionCost(
|
||||
unsigned Opcode, VectorType *Ty,
|
||||
unsigned Opcode, VectorType *Ty, Optional<FastMathFlags> FMF,
|
||||
TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency);
|
||||
|
||||
InstructionCost getMinMaxCost(Type *Ty, Type *CondTy, bool IsUnsigned);
|
||||
|
||||
@ -7252,8 +7252,15 @@ Optional<InstructionCost> LoopVectorizationCostModel::getReductionPatternCost(
|
||||
|
||||
const RecurrenceDescriptor &RdxDesc =
|
||||
Legal->getReductionVars()[cast<PHINode>(ReductionPhi)];
|
||||
InstructionCost BaseCost =
|
||||
TTI.getArithmeticReductionCost(RdxDesc.getOpcode(), VectorTy, CostKind);
|
||||
|
||||
InstructionCost BaseCost = TTI.getArithmeticReductionCost(
|
||||
RdxDesc.getOpcode(), VectorTy, RdxDesc.getFastMathFlags(), CostKind);
|
||||
|
||||
// If we're using ordered reductions then we can just return the base cost
|
||||
// here, since getArithmeticReductionCost calculates the full ordered
|
||||
// reduction cost when FP reassociation is not allowed.
|
||||
if (useOrderedReductions(RdxDesc))
|
||||
return BaseCost;
|
||||
|
||||
// Get the operand that was not the reduction chain and match it to one of the
|
||||
// patterns, returning the better cost if it is found.
|
||||
|
||||
@ -7852,7 +7852,7 @@ public:
|
||||
InstructionCost TreeCost =
|
||||
V.getTreeCost(makeArrayRef(&ReducedVals[i], ReduxWidth));
|
||||
InstructionCost ReductionCost =
|
||||
getReductionCost(TTI, ReducedVals[i], ReduxWidth);
|
||||
getReductionCost(TTI, ReducedVals[i], ReduxWidth, RdxFMF);
|
||||
InstructionCost Cost = TreeCost + ReductionCost;
|
||||
if (!Cost.isValid()) {
|
||||
LLVM_DEBUG(dbgs() << "Encountered invalid baseline cost.\n");
|
||||
@ -7944,8 +7944,8 @@ public:
|
||||
private:
|
||||
/// Calculate the cost of a reduction.
|
||||
InstructionCost getReductionCost(TargetTransformInfo *TTI,
|
||||
Value *FirstReducedVal,
|
||||
unsigned ReduxWidth) {
|
||||
Value *FirstReducedVal, unsigned ReduxWidth,
|
||||
FastMathFlags FMF) {
|
||||
Type *ScalarTy = FirstReducedVal->getType();
|
||||
FixedVectorType *VectorTy = FixedVectorType::get(ScalarTy, ReduxWidth);
|
||||
InstructionCost VectorCost, ScalarCost;
|
||||
@ -7958,7 +7958,7 @@ private:
|
||||
case RecurKind::FAdd:
|
||||
case RecurKind::FMul: {
|
||||
unsigned RdxOpcode = RecurrenceDescriptor::getOpcode(RdxKind);
|
||||
VectorCost = TTI->getArithmeticReductionCost(RdxOpcode, VectorTy);
|
||||
VectorCost = TTI->getArithmeticReductionCost(RdxOpcode, VectorTy, FMF);
|
||||
ScalarCost = TTI->getArithmeticInstrCost(RdxOpcode, ScalarTy);
|
||||
break;
|
||||
}
|
||||
|
||||
20
test/Analysis/CostModel/AArch64/reduce-fadd.ll
Normal file
20
test/Analysis/CostModel/AArch64/reduce-fadd.ll
Normal file
@ -0,0 +1,20 @@
|
||||
; RUN: opt -cost-model -analyze -mtriple=aarch64--linux-gnu < %s | FileCheck %s
|
||||
|
||||
define void @strict_fp_reductions() {
|
||||
; CHECK-LABEL: strict_fp_reductions
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 17 for instruction: %fadd_v4f32 = call float @llvm.vector.reduce.fadd.v4f32(float 0.000000e+00, <4 x float> undef)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 34 for instruction: %fadd_v8f32 = call float @llvm.vector.reduce.fadd.v8f32(float 0.000000e+00, <8 x float> undef)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 7 for instruction: %fadd_v2f64 = call double @llvm.vector.reduce.fadd.v2f64(double 0.000000e+00, <2 x double> undef)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 14 for instruction: %fadd_v4f64 = call double @llvm.vector.reduce.fadd.v4f64(double 0.000000e+00, <4 x double> undef)
|
||||
%fadd_v4f32 = call float @llvm.vector.reduce.fadd.v4f32(float 0.0, <4 x float> undef)
|
||||
%fadd_v8f32 = call float @llvm.vector.reduce.fadd.v8f32(float 0.0, <8 x float> undef)
|
||||
%fadd_v2f64 = call double @llvm.vector.reduce.fadd.v2f64(double 0.0, <2 x double> undef)
|
||||
%fadd_v4f64 = call double @llvm.vector.reduce.fadd.v4f64(double 0.0, <4 x double> undef)
|
||||
|
||||
ret void
|
||||
}
|
||||
|
||||
declare float @llvm.vector.reduce.fadd.v4f32(float, <4 x float>)
|
||||
declare float @llvm.vector.reduce.fadd.v8f32(float, <8 x float>)
|
||||
declare double @llvm.vector.reduce.fadd.v2f64(double, <2 x double>)
|
||||
declare double @llvm.vector.reduce.fadd.v4f64(double, <4 x double>)
|
||||
@ -58,21 +58,36 @@ define void @reductions(<vscale x 4 x i32> %v0, <vscale x 4 x i64> %v1, <vscale
|
||||
%smax_nxv4i32 = call i32 @llvm.vector.reduce.smax.nxv4i32(<vscale x 4 x i32> %v0)
|
||||
%smax_nxv4i64 = call i64 @llvm.vector.reduce.smax.nxv4i64(<vscale x 4 x i64> %v1)
|
||||
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %fadd_nxv4f32 = call float @llvm.vector.reduce.fadd.nxv4f32(float 0.000000e+00, <vscale x 4 x float> %v2)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %fadd_nxv4f64 = call double @llvm.vector.reduce.fadd.nxv4f64(double 0.000000e+00, <vscale x 4 x double> %v3)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %fmin_nxv4f32 = call float @llvm.vector.reduce.fmin.nxv4f32(<vscale x 4 x float> %v2)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %fmin_nxv4f64 = call double @llvm.vector.reduce.fmin.nxv4f64(<vscale x 4 x double> %v3)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %fmax_nxv4f32 = call float @llvm.vector.reduce.fmax.nxv4f32(<vscale x 4 x float> %v2)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %fmax_nxv4f64 = call double @llvm.vector.reduce.fmax.nxv4f64(<vscale x 4 x double> %v3)
|
||||
%fadd_nxv4f32 = call float @llvm.vector.reduce.fadd.nxv4f32(float 0.0, <vscale x 4 x float> %v2)
|
||||
%fadd_nxv4f64 = call double @llvm.vector.reduce.fadd.nxv4f64(double 0.0, <vscale x 4 x double> %v3)
|
||||
%fmin_nxv4f32 = call float @llvm.vector.reduce.fmin.nxv4f32(<vscale x 4 x float> %v2)
|
||||
%fmin_nxv4f64 = call double @llvm.vector.reduce.fmin.nxv4f64(<vscale x 4 x double> %v3)
|
||||
%fmax_nxv4f32 = call float @llvm.vector.reduce.fmax.nxv4f32(<vscale x 4 x float> %v2)
|
||||
%fmax_nxv4f64 = call double @llvm.vector.reduce.fmax.nxv4f64(<vscale x 4 x double> %v3)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %fadd_nxv4f32 = call fast float @llvm.vector.reduce.fadd.nxv4f32(float 0.000000e+00, <vscale x 4 x float> %v2)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %fadd_nxv4f64 = call fast double @llvm.vector.reduce.fadd.nxv4f64(double 0.000000e+00, <vscale x 4 x double> %v3)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %fmin_nxv4f32 = call fast float @llvm.vector.reduce.fmin.nxv4f32(<vscale x 4 x float> %v2)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %fmin_nxv4f64 = call fast double @llvm.vector.reduce.fmin.nxv4f64(<vscale x 4 x double> %v3)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %fmax_nxv4f32 = call fast float @llvm.vector.reduce.fmax.nxv4f32(<vscale x 4 x float> %v2)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %fmax_nxv4f64 = call fast double @llvm.vector.reduce.fmax.nxv4f64(<vscale x 4 x double> %v3)
|
||||
%fadd_nxv4f32 = call fast float @llvm.vector.reduce.fadd.nxv4f32(float 0.0, <vscale x 4 x float> %v2)
|
||||
%fadd_nxv4f64 = call fast double @llvm.vector.reduce.fadd.nxv4f64(double 0.0, <vscale x 4 x double> %v3)
|
||||
%fmin_nxv4f32 = call fast float @llvm.vector.reduce.fmin.nxv4f32(<vscale x 4 x float> %v2)
|
||||
%fmin_nxv4f64 = call fast double @llvm.vector.reduce.fmin.nxv4f64(<vscale x 4 x double> %v3)
|
||||
%fmax_nxv4f32 = call fast float @llvm.vector.reduce.fmax.nxv4f32(<vscale x 4 x float> %v2)
|
||||
%fmax_nxv4f64 = call fast double @llvm.vector.reduce.fmax.nxv4f64(<vscale x 4 x double> %v3)
|
||||
|
||||
ret void
|
||||
}
|
||||
|
||||
define void @strict_fp_reductions(<vscale x 4 x float> %v0, <vscale x 4 x double> %v1) {
|
||||
; CHECK-LABEL: 'strict_fp_reductions'
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 128 for instruction: %fadd_nxv4f32 = call float @llvm.vector.reduce.fadd.nxv4f32(float 0.000000e+00, <vscale x 4 x float> %v0)
|
||||
; CHECK-NEXT: Cost Model: Found an estimated cost of 128 for instruction: %fadd_nxv4f64 = call double @llvm.vector.reduce.fadd.nxv4f64(double 0.000000e+00, <vscale x 4 x double> %v1)
|
||||
; CHECK-NEXT: Cost Model: Invalid cost for instruction: %fmul_nxv4f32 = call float @llvm.vector.reduce.fmul.nxv4f32(float 0.000000e+00, <vscale x 4 x float> %v0)
|
||||
; CHECK-NEXT: Cost Model: Invalid cost for instruction: %fmul_nxv4f64 = call double @llvm.vector.reduce.fmul.nxv4f64(double 0.000000e+00, <vscale x 4 x double> %v1)
|
||||
%fadd_nxv4f32 = call float @llvm.vector.reduce.fadd.nxv4f32(float 0.0, <vscale x 4 x float> %v0)
|
||||
%fadd_nxv4f64 = call double @llvm.vector.reduce.fadd.nxv4f64(double 0.0, <vscale x 4 x double> %v1)
|
||||
%fmul_nxv4f32 = call float @llvm.vector.reduce.fmul.nxv4f32(float 0.0, <vscale x 4 x float> %v0)
|
||||
%fmul_nxv4f64 = call double @llvm.vector.reduce.fmul.nxv4f64(double 0.0, <vscale x 4 x double> %v1)
|
||||
|
||||
ret void
|
||||
}
|
||||
|
||||
declare i32 @llvm.vector.reduce.add.nxv4i32(<vscale x 4 x i32>)
|
||||
declare i64 @llvm.vector.reduce.add.nxv4i64(<vscale x 4 x i64>)
|
||||
declare i32 @llvm.vector.reduce.mul.nxv4i32(<vscale x 4 x i32>)
|
||||
@ -93,6 +108,8 @@ declare i32 @llvm.vector.reduce.smax.nxv4i32(<vscale x 4 x i32>)
|
||||
declare i64 @llvm.vector.reduce.smax.nxv4i64(<vscale x 4 x i64>)
|
||||
declare float @llvm.vector.reduce.fadd.nxv4f32(float, <vscale x 4 x float>)
|
||||
declare double @llvm.vector.reduce.fadd.nxv4f64(double, <vscale x 4 x double>)
|
||||
declare float @llvm.vector.reduce.fmul.nxv4f32(float, <vscale x 4 x float>)
|
||||
declare double @llvm.vector.reduce.fmul.nxv4f64(double, <vscale x 4 x double>)
|
||||
declare float @llvm.vector.reduce.fmin.nxv4f32(<vscale x 4 x float>)
|
||||
declare double @llvm.vector.reduce.fmin.nxv4f64(<vscale x 4 x double>)
|
||||
declare float @llvm.vector.reduce.fmax.nxv4f32(<vscale x 4 x float>)
|
||||
|
||||
@ -344,7 +344,7 @@ define void @reduce_fmax(<16 x float> %va) {
|
||||
|
||||
define void @reduce_fmul(<16 x float> %va) {
|
||||
; THRU-LABEL: 'reduce_fmul'
|
||||
; THRU-NEXT: Cost Model: Found an estimated cost of 12 for instruction: %v = call float @llvm.vector.reduce.fmul.v16f32(float 4.200000e+01, <16 x float> %va)
|
||||
; THRU-NEXT: Cost Model: Found an estimated cost of 44 for instruction: %v = call float @llvm.vector.reduce.fmul.v16f32(float 4.200000e+01, <16 x float> %va)
|
||||
; THRU-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; LATE-LABEL: 'reduce_fmul'
|
||||
@ -352,11 +352,11 @@ define void @reduce_fmul(<16 x float> %va) {
|
||||
; LATE-NEXT: Cost Model: Found an estimated cost of 1 for instruction: ret void
|
||||
;
|
||||
; SIZE-LABEL: 'reduce_fmul'
|
||||
; SIZE-NEXT: Cost Model: Found an estimated cost of 7 for instruction: %v = call float @llvm.vector.reduce.fmul.v16f32(float 4.200000e+01, <16 x float> %va)
|
||||
; SIZE-NEXT: Cost Model: Found an estimated cost of 28 for instruction: %v = call float @llvm.vector.reduce.fmul.v16f32(float 4.200000e+01, <16 x float> %va)
|
||||
; SIZE-NEXT: Cost Model: Found an estimated cost of 1 for instruction: ret void
|
||||
;
|
||||
; SIZE_LATE-LABEL: 'reduce_fmul'
|
||||
; SIZE_LATE-NEXT: Cost Model: Found an estimated cost of 7 for instruction: %v = call float @llvm.vector.reduce.fmul.v16f32(float 4.200000e+01, <16 x float> %va)
|
||||
; SIZE_LATE-NEXT: Cost Model: Found an estimated cost of 28 for instruction: %v = call float @llvm.vector.reduce.fmul.v16f32(float 4.200000e+01, <16 x float> %va)
|
||||
; SIZE_LATE-NEXT: Cost Model: Found an estimated cost of 1 for instruction: ret void
|
||||
;
|
||||
%v = call float @llvm.vector.reduce.fmul.v16f32(float 42.0, <16 x float> %va)
|
||||
|
||||
@ -11,59 +11,59 @@
|
||||
|
||||
define void @reduce_f64(double %arg) {
|
||||
; SSE2-LABEL: 'reduce_f64'
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 8 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 16 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 18 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 36 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 72 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSSE3-LABEL: 'reduce_f64'
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 8 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 16 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 18 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 36 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 72 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSE41-LABEL: 'reduce_f64'
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 8 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 16 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 18 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 36 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 72 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSE42-LABEL: 'reduce_f64'
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 18 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 36 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 72 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX1-LABEL: 'reduce_f64'
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 20 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 40 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 80 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX2-LABEL: 'reduce_f64'
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 20 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 40 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 80 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX512-LABEL: 'reduce_f64'
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 7 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call double @llvm.vector.reduce.fadd.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 20 for instruction: %V4 = call double @llvm.vector.reduce.fadd.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 42 for instruction: %V8 = call double @llvm.vector.reduce.fadd.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 84 for instruction: %V16 = call double @llvm.vector.reduce.fadd.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
%V1 = call double @llvm.vector.reduce.fadd.v1f64(double %arg, <1 x double> undef)
|
||||
@ -76,66 +76,66 @@ define void @reduce_f64(double %arg) {
|
||||
|
||||
define void @reduce_f32(float %arg) {
|
||||
; SSE2-LABEL: 'reduce_f32'
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 18 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 19 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 38 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 76 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 152 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSSE3-LABEL: 'reduce_f32'
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 18 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 19 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 38 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 76 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 152 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSE41-LABEL: 'reduce_f32'
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 18 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 19 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 38 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 76 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 152 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSE42-LABEL: 'reduce_f32'
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 7 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 11 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 19 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 38 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 76 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 152 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX1-LABEL: 'reduce_f32'
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 19 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 42 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 84 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 168 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX2-LABEL: 'reduce_f32'
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 7 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 19 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 42 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 84 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 168 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX512-LABEL: 'reduce_f32'
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 8 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V2 = call float @llvm.vector.reduce.fadd.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 19 for instruction: %V4 = call float @llvm.vector.reduce.fadd.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 42 for instruction: %V8 = call float @llvm.vector.reduce.fadd.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 88 for instruction: %V16 = call float @llvm.vector.reduce.fadd.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 176 for instruction: %V32 = call float @llvm.vector.reduce.fadd.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
%V1 = call float @llvm.vector.reduce.fadd.v1f32(float %arg, <1 x float> undef)
|
||||
|
||||
@ -11,59 +11,59 @@
|
||||
|
||||
define void @reduce_f64(double %arg) {
|
||||
; SSE2-LABEL: 'reduce_f64'
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 17 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 20 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 40 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSSE3-LABEL: 'reduce_f64'
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 17 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 20 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 40 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSE41-LABEL: 'reduce_f64'
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 17 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 20 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 40 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSE42-LABEL: 'reduce_f64'
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 20 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 40 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX1-LABEL: 'reduce_f64'
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 18 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 12 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 24 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 48 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX2-LABEL: 'reduce_f64'
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 7 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 12 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 24 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 48 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX512-LABEL: 'reduce_f64'
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 7 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call double @llvm.vector.reduce.fmul.v2f64(double %arg, <2 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 12 for instruction: %V4 = call double @llvm.vector.reduce.fmul.v4f64(double %arg, <4 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 26 for instruction: %V8 = call double @llvm.vector.reduce.fmul.v8f64(double %arg, <8 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 52 for instruction: %V16 = call double @llvm.vector.reduce.fmul.v16f64(double %arg, <16 x double> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
%V1 = call double @llvm.vector.reduce.fmul.v1f64(double %arg, <1 x double> undef)
|
||||
@ -76,66 +76,66 @@ define void @reduce_f64(double %arg) {
|
||||
|
||||
define void @reduce_f32(float %arg) {
|
||||
; SSE2-LABEL: 'reduce_f32'
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 8 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 12 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 20 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 11 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 22 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 44 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 88 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSSE3-LABEL: 'reduce_f32'
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 8 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 12 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 20 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 11 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 22 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 44 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 88 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSE41-LABEL: 'reduce_f32'
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 8 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 12 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 20 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 11 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 22 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 44 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 88 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE41-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; SSE42-LABEL: 'reduce_f32'
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 7 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 11 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 11 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 22 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 44 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 88 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX1-LABEL: 'reduce_f32'
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 8 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 12 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 11 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 26 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 52 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 104 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX1-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX2-LABEL: 'reduce_f32'
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 7 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 11 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 26 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 52 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 104 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX2-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
; AVX512-LABEL: 'reduce_f32'
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 4 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 6 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 8 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 9 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2 = call float @llvm.vector.reduce.fmul.v2f32(float %arg, <2 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 11 for instruction: %V4 = call float @llvm.vector.reduce.fmul.v4f32(float %arg, <4 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 26 for instruction: %V8 = call float @llvm.vector.reduce.fmul.v8f32(float %arg, <8 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 56 for instruction: %V16 = call float @llvm.vector.reduce.fmul.v16f32(float %arg, <16 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 112 for instruction: %V32 = call float @llvm.vector.reduce.fmul.v32f32(float %arg, <32 x float> undef)
|
||||
; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
|
||||
;
|
||||
%V1 = call float @llvm.vector.reduce.fmul.v1f32(float %arg, <1 x float> undef)
|
||||
|
||||
49
test/Transforms/LoopVectorize/AArch64/strict-fadd-cost.ll
Normal file
49
test/Transforms/LoopVectorize/AArch64/strict-fadd-cost.ll
Normal file
@ -0,0 +1,49 @@
|
||||
; RUN: opt < %s -loop-vectorize -debug -disable-output -enable-strict-reductions=true -hints-allow-reordering=false \
|
||||
; RUN: -force-vector-width=4 -force-vector-interleave=1 -S 2>&1 | FileCheck %s --check-prefix=CHECK-VF4
|
||||
; RUN: opt < %s -loop-vectorize -debug -disable-output -enable-strict-reductions=true -hints-allow-reordering=false \
|
||||
; RUN: -force-vector-width=8 -force-vector-interleave=1 -S 2>&1 | FileCheck %s --check-prefix=CHECK-VF8
|
||||
|
||||
target triple="aarch64-unknown-linux-gnu"
|
||||
|
||||
; CHECK-VF4: Found an estimated cost of 17 for VF 4 For instruction: %add = fadd float %0, %sum.07
|
||||
; CHECK-VF8: Found an estimated cost of 34 for VF 8 For instruction: %add = fadd float %0, %sum.07
|
||||
|
||||
define float @fadd_strict32(float* noalias nocapture readonly %a, i64 %n) {
|
||||
entry:
|
||||
br label %for.body
|
||||
|
||||
for.body:
|
||||
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
|
||||
%sum.07 = phi float [ 0.000000e+00, %entry ], [ %add, %for.body ]
|
||||
%arrayidx = getelementptr inbounds float, float* %a, i64 %iv
|
||||
%0 = load float, float* %arrayidx, align 4
|
||||
%add = fadd float %0, %sum.07
|
||||
%iv.next = add nuw nsw i64 %iv, 1
|
||||
%exitcond.not = icmp eq i64 %iv.next, %n
|
||||
br i1 %exitcond.not, label %for.end, label %for.body
|
||||
|
||||
for.end:
|
||||
ret float %add
|
||||
}
|
||||
|
||||
|
||||
; CHECK-VF4: Found an estimated cost of 14 for VF 4 For instruction: %add = fadd double %0, %sum.07
|
||||
; CHECK-VF8: Found an estimated cost of 28 for VF 8 For instruction: %add = fadd double %0, %sum.07
|
||||
|
||||
define double @fadd_strict64(double* noalias nocapture readonly %a, i64 %n) {
|
||||
entry:
|
||||
br label %for.body
|
||||
|
||||
for.body:
|
||||
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
|
||||
%sum.07 = phi double [ 0.000000e+00, %entry ], [ %add, %for.body ]
|
||||
%arrayidx = getelementptr inbounds double, double* %a, i64 %iv
|
||||
%0 = load double, double* %arrayidx, align 4
|
||||
%add = fadd double %0, %sum.07
|
||||
%iv.next = add nuw nsw i64 %iv, 1
|
||||
%exitcond.not = icmp eq i64 %iv.next, %n
|
||||
br i1 %exitcond.not, label %for.end, label %for.body
|
||||
|
||||
for.end:
|
||||
ret double %add
|
||||
}
|
||||
@ -0,0 +1,54 @@
|
||||
; RUN: opt < %s -loop-vectorize -debug -disable-output -enable-strict-reductions=true -hints-allow-reordering=false \
|
||||
; RUN: -scalable-vectorization=on -force-vector-width=4 -force-vector-interleave=1 -S 2>&1 | FileCheck %s --check-prefix=CHECK-VF4
|
||||
; RUN: opt < %s -loop-vectorize -debug -disable-output -enable-strict-reductions=true -hints-allow-reordering=false \
|
||||
; RUN: -scalable-vectorization=on -force-vector-width=8 -force-vector-interleave=1 -S 2>&1 | FileCheck %s --check-prefix=CHECK-VF8
|
||||
|
||||
target triple="aarch64-unknown-linux-gnu"
|
||||
|
||||
; CHECK-VF4: Found an estimated cost of 128 for VF vscale x 4 For instruction: %add = fadd float %0, %sum.07
|
||||
; CHECK-VF8: Found an estimated cost of 256 for VF vscale x 8 For instruction: %add = fadd float %0, %sum.07
|
||||
|
||||
define float @fadd_strict32(float* noalias nocapture readonly %a, i64 %n) #0 {
|
||||
entry:
|
||||
br label %for.body
|
||||
|
||||
for.body:
|
||||
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
|
||||
%sum.07 = phi float [ 0.000000e+00, %entry ], [ %add, %for.body ]
|
||||
%arrayidx = getelementptr inbounds float, float* %a, i64 %iv
|
||||
%0 = load float, float* %arrayidx, align 4
|
||||
%add = fadd float %0, %sum.07
|
||||
%iv.next = add nuw nsw i64 %iv, 1
|
||||
%exitcond.not = icmp eq i64 %iv.next, %n
|
||||
br i1 %exitcond.not, label %for.end, label %for.body, !llvm.loop !0
|
||||
|
||||
for.end:
|
||||
ret float %add
|
||||
}
|
||||
|
||||
|
||||
; CHECK-VF4: Found an estimated cost of 128 for VF vscale x 4 For instruction: %add = fadd double %0, %sum.07
|
||||
; CHECK-VF8: Found an estimated cost of 256 for VF vscale x 8 For instruction: %add = fadd double %0, %sum.07
|
||||
|
||||
define double @fadd_strict64(double* noalias nocapture readonly %a, i64 %n) #0 {
|
||||
entry:
|
||||
br label %for.body
|
||||
|
||||
for.body:
|
||||
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
|
||||
%sum.07 = phi double [ 0.000000e+00, %entry ], [ %add, %for.body ]
|
||||
%arrayidx = getelementptr inbounds double, double* %a, i64 %iv
|
||||
%0 = load double, double* %arrayidx, align 4
|
||||
%add = fadd double %0, %sum.07
|
||||
%iv.next = add nuw nsw i64 %iv, 1
|
||||
%exitcond.not = icmp eq i64 %iv.next, %n
|
||||
br i1 %exitcond.not, label %for.end, label %for.body, !llvm.loop !0
|
||||
|
||||
for.end:
|
||||
ret double %add
|
||||
}
|
||||
|
||||
attributes #0 = { "target-features"="+sve" }
|
||||
|
||||
!0 = distinct !{!0, !1}
|
||||
!1 = !{!"llvm.loop.vectorize.scalable.enable", i1 true}
|
||||
Loading…
x
Reference in New Issue
Block a user