This is an archive of the discontinued LLVM Phabricator instance.

Differential D153548

[TTI][AArch64] Add basic vector_reduce_fmaximum/vector_reduce_fminimum costmodelling
ClosedPublic

Authored by dmgreen on Jun 22 2023, 7:03 AM.

Details

Reviewers
RKSimon
anna
spatel
nikic
Commits
rGed9cb663765c: [TTI][AArch64] Add basic vector_reduce_fmaximum/vector_reduce_fminimum…
Summary

This adds some basic handling in TargetTransformInfo to treat vector_reduce_fminimum/vector_reduce_fmaximum similar to vector_reduce_fmax/vector_reduce_fmax, getting better costs via getMinMaxReductionCost.

Diff Detail

Revision Contents

PathSize
llvm/
include/
llvm/
CodeGen/
8 lines
test/
Analysis/
CostModel/
AArch64/
52 lines

Diff 537125

llvm/include/llvm/CodeGen/BasicTTIImpl.h

Show First 20 Lines • Show All 1,596 Lines • ▼ Show 20 Lines InstructionCost getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
case Intrinsic::vector_reduce_mul: case Intrinsic::vector_reduce_mul:
case Intrinsic::vector_reduce_and: case Intrinsic::vector_reduce_and:
case Intrinsic::vector_reduce_or: case Intrinsic::vector_reduce_or:
case Intrinsic::vector_reduce_xor: case Intrinsic::vector_reduce_xor:
case Intrinsic::vector_reduce_smax: case Intrinsic::vector_reduce_smax:
case Intrinsic::vector_reduce_smin: case Intrinsic::vector_reduce_smin:
case Intrinsic::vector_reduce_fmax: case Intrinsic::vector_reduce_fmax:
case Intrinsic::vector_reduce_fmin: case Intrinsic::vector_reduce_fmin:
case Intrinsic::vector_reduce_fmaximum:
case Intrinsic::vector_reduce_fminimum:
case Intrinsic::vector_reduce_umax: case Intrinsic::vector_reduce_umax:
case Intrinsic::vector_reduce_umin: { case Intrinsic::vector_reduce_umin: {
IntrinsicCostAttributes Attrs(IID, RetTy, Args[0]->getType(), FMF, I, 1); IntrinsicCostAttributes Attrs(IID, RetTy, Args[0]->getType(), FMF, I, 1);
return getTypeBasedIntrinsicInstrCost(Attrs, CostKind); return getTypeBasedIntrinsicInstrCost(Attrs, CostKind);
} }
case Intrinsic::vector_reduce_fadd: case Intrinsic::vector_reduce_fadd:
case Intrinsic::vector_reduce_fmul: { case Intrinsic::vector_reduce_fmul: {
IntrinsicCostAttributes Attrs( IntrinsicCostAttributes Attrs(
▲ Show 20 Lines • Show All 289 Lines • ▼ Show 20 Lines case Intrinsic::vector_reduce_umin:
return thisT()->getMinMaxReductionCost(Intrinsic::umin, VecOpTy, return thisT()->getMinMaxReductionCost(Intrinsic::umin, VecOpTy,
ICA.getFlags(), CostKind); ICA.getFlags(), CostKind);
case Intrinsic::vector_reduce_fmax: case Intrinsic::vector_reduce_fmax:
return thisT()->getMinMaxReductionCost(Intrinsic::maxnum, VecOpTy, return thisT()->getMinMaxReductionCost(Intrinsic::maxnum, VecOpTy,
ICA.getFlags(), CostKind); ICA.getFlags(), CostKind);
case Intrinsic::vector_reduce_fmin: case Intrinsic::vector_reduce_fmin:
return thisT()->getMinMaxReductionCost(Intrinsic::minnum, VecOpTy, return thisT()->getMinMaxReductionCost(Intrinsic::minnum, VecOpTy,
ICA.getFlags(), CostKind); ICA.getFlags(), CostKind);
case Intrinsic::vector_reduce_fmaximum:
return thisT()->getMinMaxReductionCost(Intrinsic::maximum, VecOpTy,
ICA.getFlags(), CostKind);
case Intrinsic::vector_reduce_fminimum:
return thisT()->getMinMaxReductionCost(Intrinsic::minimum, VecOpTy,
ICA.getFlags(), CostKind);
case Intrinsic::abs: { case Intrinsic::abs: {
// abs(X) = select(icmp(X,0),X,sub(0,X)) // abs(X) = select(icmp(X,0),X,sub(0,X))
Type *CondTy = RetTy->getWithNewBitWidth(1); Type *CondTy = RetTy->getWithNewBitWidth(1);
CmpInst::Predicate Pred = CmpInst::ICMP_SGT; CmpInst::Predicate Pred = CmpInst::ICMP_SGT;
InstructionCost Cost = 0; InstructionCost Cost = 0;
Cost += thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy, Cost += thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy,
Pred, CostKind); Pred, CostKind);
Cost += thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy, CondTy, Cost += thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy, CondTy,
▲ Show 20 Lines • Show All 548 Lines • Show Last 20 Lines

llvm/test/Analysis/CostModel/AArch64/reduce-minmax.ll

Show First 20 Lines • Show All 160 Lines • ▼ Show 20 Lines
} }
define void @reduce_fmin16() { define void @reduce_fmin16() {
; CHECK-NOF16-LABEL: 'reduce_fmin16' ; CHECK-NOF16-LABEL: 'reduce_fmin16'
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 14 for instruction: %V2f16 = call half @llvm.vector.reduce.fmin.v2f16(<2 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 14 for instruction: %V2f16 = call half @llvm.vector.reduce.fmin.v2f16(<2 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 68 for instruction: %V4f16 = call half @llvm.vector.reduce.fmin.v4f16(<4 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 68 for instruction: %V4f16 = call half @llvm.vector.reduce.fmin.v4f16(<4 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 237 for instruction: %V8f16 = call half @llvm.vector.reduce.fmin.v8f16(<8 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 237 for instruction: %V8f16 = call half @llvm.vector.reduce.fmin.v8f16(<8 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 350 for instruction: %V16f16 = call half @llvm.vector.reduce.fmin.v16f16(<16 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 350 for instruction: %V16f16 = call half @llvm.vector.reduce.fmin.v16f16(<16 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2f16m = call half @llvm.vector.reduce.fminimum.v2f16(<2 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 14 for instruction: %V2f16m = call half @llvm.vector.reduce.fminimum.v2f16(<2 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 13 for instruction: %V4f16m = call half @llvm.vector.reduce.fminimum.v4f16(<4 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 68 for instruction: %V4f16m = call half @llvm.vector.reduce.fminimum.v4f16(<4 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 29 for instruction: %V8f16m = call half @llvm.vector.reduce.fminimum.v8f16(<8 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 237 for instruction: %V8f16m = call half @llvm.vector.reduce.fminimum.v8f16(<8 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 58 for instruction: %V16f16m = call half @llvm.vector.reduce.fminimum.v16f16(<16 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 350 for instruction: %V16f16m = call half @llvm.vector.reduce.fminimum.v16f16(<16 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
; ;
; CHECK-F16-LABEL: 'reduce_fmin16' ; CHECK-F16-LABEL: 'reduce_fmin16'
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f16 = call half @llvm.vector.reduce.fmin.v2f16(<2 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f16 = call half @llvm.vector.reduce.fmin.v2f16(<2 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f16 = call half @llvm.vector.reduce.fmin.v4f16(<4 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f16 = call half @llvm.vector.reduce.fmin.v4f16(<4 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V8f16 = call half @llvm.vector.reduce.fmin.v8f16(<8 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V8f16 = call half @llvm.vector.reduce.fmin.v8f16(<8 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V16f16 = call half @llvm.vector.reduce.fmin.v16f16(<16 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V16f16 = call half @llvm.vector.reduce.fmin.v16f16(<16 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2f16m = call half @llvm.vector.reduce.fminimum.v2f16(<2 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f16m = call half @llvm.vector.reduce.fminimum.v2f16(<2 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 13 for instruction: %V4f16m = call half @llvm.vector.reduce.fminimum.v4f16(<4 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f16m = call half @llvm.vector.reduce.fminimum.v4f16(<4 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 29 for instruction: %V8f16m = call half @llvm.vector.reduce.fminimum.v8f16(<8 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V8f16m = call half @llvm.vector.reduce.fminimum.v8f16(<8 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 58 for instruction: %V16f16m = call half @llvm.vector.reduce.fminimum.v16f16(<16 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V16f16m = call half @llvm.vector.reduce.fminimum.v16f16(<16 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
; ;
%V2f16 = call half @llvm.vector.reduce.fmin.v2f16(<2 x half> undef) %V2f16 = call half @llvm.vector.reduce.fmin.v2f16(<2 x half> undef)
%V4f16 = call half @llvm.vector.reduce.fmin.v4f16(<4 x half> undef) %V4f16 = call half @llvm.vector.reduce.fmin.v4f16(<4 x half> undef)
%V8f16 = call half @llvm.vector.reduce.fmin.v8f16(<8 x half> undef) %V8f16 = call half @llvm.vector.reduce.fmin.v8f16(<8 x half> undef)
%V16f16 = call half @llvm.vector.reduce.fmin.v16f16(<16 x half> undef) %V16f16 = call half @llvm.vector.reduce.fmin.v16f16(<16 x half> undef)
%V2f16m = call half @llvm.vector.reduce.fminimum.v2f16(<2 x half> undef) %V2f16m = call half @llvm.vector.reduce.fminimum.v2f16(<2 x half> undef)
%V4f16m = call half @llvm.vector.reduce.fminimum.v4f16(<4 x half> undef) %V4f16m = call half @llvm.vector.reduce.fminimum.v4f16(<4 x half> undef)
%V8f16m = call half @llvm.vector.reduce.fminimum.v8f16(<8 x half> undef) %V8f16m = call half @llvm.vector.reduce.fminimum.v8f16(<8 x half> undef)
%V16f16m = call half @llvm.vector.reduce.fminimum.v16f16(<16 x half> undef) %V16f16m = call half @llvm.vector.reduce.fminimum.v16f16(<16 x half> undef)
ret void ret void
} }
define void @reduce_fmax16() { define void @reduce_fmax16() {
; CHECK-NOF16-LABEL: 'reduce_fmax16' ; CHECK-NOF16-LABEL: 'reduce_fmax16'
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 14 for instruction: %V2f16 = call half @llvm.vector.reduce.fmax.v2f16(<2 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 14 for instruction: %V2f16 = call half @llvm.vector.reduce.fmax.v2f16(<2 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 68 for instruction: %V4f16 = call half @llvm.vector.reduce.fmax.v4f16(<4 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 68 for instruction: %V4f16 = call half @llvm.vector.reduce.fmax.v4f16(<4 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 237 for instruction: %V8f16 = call half @llvm.vector.reduce.fmax.v8f16(<8 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 237 for instruction: %V8f16 = call half @llvm.vector.reduce.fmax.v8f16(<8 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 350 for instruction: %V16f16 = call half @llvm.vector.reduce.fmax.v16f16(<16 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 350 for instruction: %V16f16 = call half @llvm.vector.reduce.fmax.v16f16(<16 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2f16m = call half @llvm.vector.reduce.fmaximum.v2f16(<2 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 14 for instruction: %V2f16m = call half @llvm.vector.reduce.fmaximum.v2f16(<2 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 13 for instruction: %V4f16m = call half @llvm.vector.reduce.fmaximum.v4f16(<4 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 68 for instruction: %V4f16m = call half @llvm.vector.reduce.fmaximum.v4f16(<4 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 29 for instruction: %V8f16m = call half @llvm.vector.reduce.fmaximum.v8f16(<8 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 237 for instruction: %V8f16m = call half @llvm.vector.reduce.fmaximum.v8f16(<8 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 58 for instruction: %V16f16m = call half @llvm.vector.reduce.fmaximum.v16f16(<16 x half> undef) ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 350 for instruction: %V16f16m = call half @llvm.vector.reduce.fmaximum.v16f16(<16 x half> undef)
; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void ; CHECK-NOF16-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
; ;
; CHECK-F16-LABEL: 'reduce_fmax16' ; CHECK-F16-LABEL: 'reduce_fmax16'
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f16 = call half @llvm.vector.reduce.fmax.v2f16(<2 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f16 = call half @llvm.vector.reduce.fmax.v2f16(<2 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f16 = call half @llvm.vector.reduce.fmax.v4f16(<4 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f16 = call half @llvm.vector.reduce.fmax.v4f16(<4 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V8f16 = call half @llvm.vector.reduce.fmax.v8f16(<8 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V8f16 = call half @llvm.vector.reduce.fmax.v8f16(<8 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V16f16 = call half @llvm.vector.reduce.fmax.v16f16(<16 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V16f16 = call half @llvm.vector.reduce.fmax.v16f16(<16 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2f16m = call half @llvm.vector.reduce.fmaximum.v2f16(<2 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f16m = call half @llvm.vector.reduce.fmaximum.v2f16(<2 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 13 for instruction: %V4f16m = call half @llvm.vector.reduce.fmaximum.v4f16(<4 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f16m = call half @llvm.vector.reduce.fmaximum.v4f16(<4 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 29 for instruction: %V8f16m = call half @llvm.vector.reduce.fmaximum.v8f16(<8 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V8f16m = call half @llvm.vector.reduce.fmaximum.v8f16(<8 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 58 for instruction: %V16f16m = call half @llvm.vector.reduce.fmaximum.v16f16(<16 x half> undef) ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V16f16m = call half @llvm.vector.reduce.fmaximum.v16f16(<16 x half> undef)
; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void ; CHECK-F16-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
; ;
%V2f16 = call half @llvm.vector.reduce.fmax.v2f16(<2 x half> undef) %V2f16 = call half @llvm.vector.reduce.fmax.v2f16(<2 x half> undef)
%V4f16 = call half @llvm.vector.reduce.fmax.v4f16(<4 x half> undef) %V4f16 = call half @llvm.vector.reduce.fmax.v4f16(<4 x half> undef)
%V8f16 = call half @llvm.vector.reduce.fmax.v8f16(<8 x half> undef) %V8f16 = call half @llvm.vector.reduce.fmax.v8f16(<8 x half> undef)
%V16f16 = call half @llvm.vector.reduce.fmax.v16f16(<16 x half> undef) %V16f16 = call half @llvm.vector.reduce.fmax.v16f16(<16 x half> undef)
%V2f16m = call half @llvm.vector.reduce.fmaximum.v2f16(<2 x half> undef) %V2f16m = call half @llvm.vector.reduce.fmaximum.v2f16(<2 x half> undef)
%V4f16m = call half @llvm.vector.reduce.fmaximum.v4f16(<4 x half> undef) %V4f16m = call half @llvm.vector.reduce.fmaximum.v4f16(<4 x half> undef)
%V8f16m = call half @llvm.vector.reduce.fmaximum.v8f16(<8 x half> undef) %V8f16m = call half @llvm.vector.reduce.fmaximum.v8f16(<8 x half> undef)
%V16f16m = call half @llvm.vector.reduce.fmaximum.v16f16(<16 x half> undef) %V16f16m = call half @llvm.vector.reduce.fmaximum.v16f16(<16 x half> undef)
ret void ret void
} }
define void @reduce_fmin() { define void @reduce_fmin() {
; CHECK-LABEL: 'reduce_fmin' ; CHECK-LABEL: 'reduce_fmin'
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f32 = call float @llvm.vector.reduce.fmin.v2f32(<2 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f32 = call float @llvm.vector.reduce.fmin.v2f32(<2 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f32 = call float @llvm.vector.reduce.fmin.v4f32(<4 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f32 = call float @llvm.vector.reduce.fmin.v4f32(<4 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V8f32 = call float @llvm.vector.reduce.fmin.v8f32(<8 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V8f32 = call float @llvm.vector.reduce.fmin.v8f32(<8 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f64 = call double @llvm.vector.reduce.fmin.v2f64(<2 x double> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f64 = call double @llvm.vector.reduce.fmin.v2f64(<2 x double> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4f64 = call double @llvm.vector.reduce.fmin.v4f64(<4 x double> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4f64 = call double @llvm.vector.reduce.fmin.v4f64(<4 x double> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2f32m = call float @llvm.vector.reduce.fminimum.v2f32(<2 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f32m = call float @llvm.vector.reduce.fminimum.v2f32(<2 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 13 for instruction: %V4f32m = call float @llvm.vector.reduce.fminimum.v4f32(<4 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f32m = call float @llvm.vector.reduce.fminimum.v4f32(<4 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 26 for instruction: %V8f32m = call float @llvm.vector.reduce.fminimum.v8f32(<8 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V8f32m = call float @llvm.vector.reduce.fminimum.v8f32(<8 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2f64m = call double @llvm.vector.reduce.fminimum.v2f64(<2 x double> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f64m = call double @llvm.vector.reduce.fminimum.v2f64(<2 x double> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V4f64m = call double @llvm.vector.reduce.fminimum.v4f64(<4 x double> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4f64m = call double @llvm.vector.reduce.fminimum.v4f64(<4 x double> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void ; CHECK-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
; ;
%V2f32 = call float @llvm.vector.reduce.fmin.v2f32(<2 x float> undef) %V2f32 = call float @llvm.vector.reduce.fmin.v2f32(<2 x float> undef)
%V4f32 = call float @llvm.vector.reduce.fmin.v4f32(<4 x float> undef) %V4f32 = call float @llvm.vector.reduce.fmin.v4f32(<4 x float> undef)
%V8f32 = call float @llvm.vector.reduce.fmin.v8f32(<8 x float> undef) %V8f32 = call float @llvm.vector.reduce.fmin.v8f32(<8 x float> undef)
%V2f64 = call double @llvm.vector.reduce.fmin.v2f64(<2 x double> undef) %V2f64 = call double @llvm.vector.reduce.fmin.v2f64(<2 x double> undef)
%V4f64 = call double @llvm.vector.reduce.fmin.v4f64(<4 x double> undef) %V4f64 = call double @llvm.vector.reduce.fmin.v4f64(<4 x double> undef)
%V2f32m = call float @llvm.vector.reduce.fminimum.v2f32(<2 x float> undef) %V2f32m = call float @llvm.vector.reduce.fminimum.v2f32(<2 x float> undef)
%V4f32m = call float @llvm.vector.reduce.fminimum.v4f32(<4 x float> undef) %V4f32m = call float @llvm.vector.reduce.fminimum.v4f32(<4 x float> undef)
%V8f32m = call float @llvm.vector.reduce.fminimum.v8f32(<8 x float> undef) %V8f32m = call float @llvm.vector.reduce.fminimum.v8f32(<8 x float> undef)
%V2f64m = call double @llvm.vector.reduce.fminimum.v2f64(<2 x double> undef) %V2f64m = call double @llvm.vector.reduce.fminimum.v2f64(<2 x double> undef)
%V4f64m = call double @llvm.vector.reduce.fminimum.v4f64(<4 x double> undef) %V4f64m = call double @llvm.vector.reduce.fminimum.v4f64(<4 x double> undef)
ret void ret void
} }
define void @reduce_fmax() { define void @reduce_fmax() {
; CHECK-LABEL: 'reduce_fmax' ; CHECK-LABEL: 'reduce_fmax'
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f32 = call float @llvm.vector.reduce.fmax.v2f32(<2 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f32 = call float @llvm.vector.reduce.fmax.v2f32(<2 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f32 = call float @llvm.vector.reduce.fmax.v4f32(<4 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f32 = call float @llvm.vector.reduce.fmax.v4f32(<4 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V8f32 = call float @llvm.vector.reduce.fmax.v8f32(<8 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V8f32 = call float @llvm.vector.reduce.fmax.v8f32(<8 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f64 = call double @llvm.vector.reduce.fmax.v2f64(<2 x double> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f64 = call double @llvm.vector.reduce.fmax.v2f64(<2 x double> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4f64 = call double @llvm.vector.reduce.fmax.v4f64(<4 x double> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4f64 = call double @llvm.vector.reduce.fmax.v4f64(<4 x double> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2f32m = call float @llvm.vector.reduce.fmaximum.v2f32(<2 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f32m = call float @llvm.vector.reduce.fmaximum.v2f32(<2 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 13 for instruction: %V4f32m = call float @llvm.vector.reduce.fmaximum.v4f32(<4 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V4f32m = call float @llvm.vector.reduce.fmaximum.v4f32(<4 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 26 for instruction: %V8f32m = call float @llvm.vector.reduce.fmaximum.v8f32(<8 x float> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V8f32m = call float @llvm.vector.reduce.fmaximum.v8f32(<8 x float> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 5 for instruction: %V2f64m = call double @llvm.vector.reduce.fmaximum.v2f64(<2 x double> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 2 for instruction: %V2f64m = call double @llvm.vector.reduce.fmaximum.v2f64(<2 x double> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 10 for instruction: %V4f64m = call double @llvm.vector.reduce.fmaximum.v4f64(<4 x double> undef) ; CHECK-NEXT: Cost Model: Found an estimated cost of 3 for instruction: %V4f64m = call double @llvm.vector.reduce.fmaximum.v4f64(<4 x double> undef)
; CHECK-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void ; CHECK-NEXT: Cost Model: Found an estimated cost of 0 for instruction: ret void
; ;
%V2f32 = call float @llvm.vector.reduce.fmax.v2f32(<2 x float> undef) %V2f32 = call float @llvm.vector.reduce.fmax.v2f32(<2 x float> undef)
%V4f32 = call float @llvm.vector.reduce.fmax.v4f32(<4 x float> undef) %V4f32 = call float @llvm.vector.reduce.fmax.v4f32(<4 x float> undef)
%V8f32 = call float @llvm.vector.reduce.fmax.v8f32(<8 x float> undef) %V8f32 = call float @llvm.vector.reduce.fmax.v8f32(<8 x float> undef)
%V2f64 = call double @llvm.vector.reduce.fmax.v2f64(<2 x double> undef) %V2f64 = call double @llvm.vector.reduce.fmax.v2f64(<2 x double> undef)
%V4f64 = call double @llvm.vector.reduce.fmax.v4f64(<4 x double> undef) %V4f64 = call double @llvm.vector.reduce.fmax.v4f64(<4 x double> undef)
%V2f32m = call float @llvm.vector.reduce.fmaximum.v2f32(<2 x float> undef) %V2f32m = call float @llvm.vector.reduce.fmaximum.v2f32(<2 x float> undef)
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines