[llvm] 037a48a - [InstCombine] fold fabs(uitofp(i16 a) - uitofp(i16 b)) < 1.0 to a == b (#191378)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Apr 21 05:05:05 PDT 2026
Author: Shreeyash Pandey
Date: 2026-04-21T17:35:00+05:30
New Revision: 037a48aa4b9a6da45bb72aba4304a99dc0491792
URL: https://github.com/llvm/llvm-project/commit/037a48aa4b9a6da45bb72aba4304a99dc0491792
DIFF: https://github.com/llvm/llvm-project/commit/037a48aa4b9a6da45bb72aba4304a99dc0491792.diff
LOG: [InstCombine] fold fabs(uitofp(i16 a) - uitofp(i16 b)) < 1.0 to a == b (#191378)
Fixes: https://github.com/llvm/llvm-project/issues/187088
When a and b are types with bitwidth (16 bits) smaller than the mantissa
for float32 (24 bits), they will be exact and their absolute difference
would be integral ±1 or greater if a != b. On the corollary, if their
difference is < 1.0, this implies that a = b.
This patch exploits this fact to fold the expression to just a single
icmp.
Added:
Modified:
llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
llvm/test/Transforms/InstCombine/fcmp.ll
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
index a115eb31c0529..6f1ab31fe03b2 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
@@ -8801,6 +8801,73 @@ static Instruction *foldFCmpFSubIntoFCmp(FCmpInst &I, Instruction *LHSI,
return nullptr;
}
+/// Fold: fabs(uitofp(a) - uitofp(b)) pred C --> a == b
+/// where 'pred' is olt, ult, ogt, ugt, oge or uge and C is a positive, Non-NaN
+/// float when the uitofp casts are exact and C is in the valid range.
+///
+/// Since exact uitofp means distinct integers map to distinct floats, the only
+/// values fabs(uitofp(a) - uitofp(b)) can take are {0.0, 1.0, 2.0, ...}.
+/// There are no values in the open interval (0, 1), so:
+/// fabs(...) < C where 0 < C <= 1.0 --> a == b (strict lt: C=1.0 ok)
+// fabs(..) >= C where C >= 1.0 -> a != b
+///
+/// The same logic applies to sitofp.
+static Instruction *foldFCmpFAbsFSubIntToFP(FCmpInst &I, InstCombinerImpl &IC) {
+ Value *FAbsArg;
+ if (!match(I.getOperand(0), m_FAbs(m_Value(FAbsArg))))
+ return nullptr;
+
+ const APFloat *C;
+ if (!match(I.getOperand(1), PatternMatch::m_FiniteNonZero(C)))
+ return nullptr;
+
+ FCmpInst::Predicate Pred = I.getPredicate();
+ bool IsStrictLt = Pred == FCmpInst::FCMP_OLT || Pred == FCmpInst::FCMP_ULT;
+ bool IsLe = Pred == FCmpInst::FCMP_OLE || Pred == FCmpInst::FCMP_ULE;
+ bool IsStrictGt = Pred == FCmpInst::FCMP_OGT || Pred == FCmpInst::FCMP_UGT;
+ bool IsGe = Pred == FCmpInst::FCMP_OGE || Pred == FCmpInst::FCMP_UGE;
+ if (!IsStrictLt && !IsStrictGt && !IsGe)
+ return nullptr;
+
+ APFloat One = APFloat::getOne(C->getSemantics());
+ APFloat::cmpResult Cmp = C->compare(One);
+
+ // For strict-lt (olt/ult): C must be in (0, 1.0] -- C == 1.0 is fine since
+ // the next possible value after 0.0 is 1.0, and < 1.0 excludes it.
+ if (IsStrictLt && Cmp == APFloat::cmpGreaterThan)
+ return nullptr;
+ if (IsGe && Cmp == APFloat::cmpGreaterThan)
+ return nullptr;
+ if (IsLe && Cmp != APFloat::cmpGreaterThan)
+ return nullptr;
+ if (IsStrictGt && Cmp != APFloat::cmpLessThan)
+ return nullptr;
+
+ // Match: fsub(uitofp(A), uitofp(B)) where both casts are uitofp or sitofp
+ Value *A, *B;
+ bool IsSigned;
+ if (match(FAbsArg, m_FSub(m_UIToFP(m_Value(A)), m_UIToFP(m_Value(B))))) {
+ IsSigned = false;
+ } else if (match(FAbsArg,
+ m_FSub(m_SIToFP(m_Value(A)), m_SIToFP(m_Value(B))))) {
+ IsSigned = true;
+ } else {
+ return nullptr;
+ }
+
+ // A and B must have the same integer type
+ if (A->getType() != B->getType())
+ return nullptr;
+
+ Type *FPTy = FAbsArg->getType();
+ if (!IC.canBeCastedExactlyIntToFP(A, FPTy, IsSigned, &I) ||
+ !IC.canBeCastedExactlyIntToFP(B, FPTy, IsSigned, &I))
+ return nullptr;
+ ICmpInst::Predicate ResultPred =
+ IsStrictLt || IsLe ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE;
+ return new ICmpInst(ResultPred, A, B);
+}
+
static Instruction *foldFCmpWithFloorAndCeil(FCmpInst &I,
InstCombinerImpl &IC) {
Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
@@ -9114,6 +9181,9 @@ Instruction *InstCombinerImpl::visitFCmpInst(FCmpInst &I) {
if (Instruction *R = foldFabsWithFcmpZero(I, *this))
return R;
+ if (Instruction *R = foldFCmpFAbsFSubIntToFP(I, *this))
+ return R;
+
if (Instruction *R = foldSqrtWithFcmpZero(I, *this))
return R;
diff --git a/llvm/test/Transforms/InstCombine/fcmp.ll b/llvm/test/Transforms/InstCombine/fcmp.ll
index e3c43812cedd6..76a3ce01cb746 100644
--- a/llvm/test/Transforms/InstCombine/fcmp.ll
+++ b/llvm/test/Transforms/InstCombine/fcmp.ll
@@ -2,6 +2,7 @@
; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare half @llvm.fabs.f16(half)
+declare float @llvm.fabs.f32(float)
declare double @llvm.fabs.f64(double)
declare <2 x float> @llvm.fabs.v2f32(<2 x float>)
declare double @llvm.copysign.f64(double, double)
@@ -1849,7 +1850,6 @@ define i1 @same_const_sub_uitofp_olt(i32 %x) {
define i1 @same_const_sub_no_fold_large_c(i32 %x) {
; CHECK-LABEL: @same_const_sub_no_fold_large_c(
-; CHECK-NOT: icmp
; CHECK-NEXT: [[F:%.*]] = sitofp i32 [[X:%.*]] to float
; CHECK-NEXT: [[S:%.*]] = fsub float 0x417FFFFFE0000000, [[F]]
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[S]], 0x417FFFFFE0000000
@@ -1869,7 +1869,7 @@ define <2 x i1> @same_const_sub_sitofp_vec_eq(<2 x i32> %x) {
%f = sitofp <2 x i32> %x to <2 x float>
%s = fsub <2 x float> <float 1.000000e+00, float 1.000000e+00>, %f
%cmp = fcmp oeq <2 x float> %s,
- <float 1.000000e+00, float 1.000000e+00>
+ <float 1.000000e+00, float 1.000000e+00>
ret <2 x i1> %cmp
}
@@ -1881,7 +1881,7 @@ define <2 x i1> @same_const_sub_uitofp_vec_olt(<2 x i32> %x) {
%f = uitofp <2 x i32> %x to <2 x float>
%s = fsub <2 x float> <float 2.000000e+00, float 2.000000e+00>, %f
%cmp = fcmp olt <2 x float> %s,
- <float 2.000000e+00, float 2.000000e+00>
+ <float 2.000000e+00, float 2.000000e+00>
ret <2 x i1> %cmp
}
@@ -1924,7 +1924,6 @@ define i1 @same_const_sub_sitofp_x86_fp80_eq(i32 %x) {
define i1 @same_const_sub_no_fold_x86_fp80_large_c(i32 %x) {
; CHECK-LABEL: @same_const_sub_no_fold_x86_fp80_large_c(
-; CHECK-NOT: icmp
; CHECK-NEXT: [[F:%.*]] = sitofp i32 [[X:%.*]] to x86_fp80
; CHECK-NEXT: [[S:%.*]] = fsub x86_fp80 0xK403F8000000000000000, [[F]]
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq x86_fp80 [[S]], 0xK403F8000000000000000
@@ -1939,7 +1938,6 @@ define i1 @same_const_sub_no_fold_x86_fp80_large_c(i32 %x) {
define i1 @same_const_sub_no_fold_ppcfp128(i32 %x) {
; CHECK-LABEL: @same_const_sub_no_fold_ppcfp128(
-; CHECK-NOT: icmp
; CHECK-NEXT: [[F:%.*]] = sitofp i32 [[X:%.*]] to ppc_fp128
; CHECK-NEXT: [[S:%.*]] = fsub ppc_fp128 0xM3FF00000000000000000000000000000, [[F]]
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq ppc_fp128 [[S]], 0xM3FF00000000000000000000000000000
@@ -2581,3 +2579,259 @@ define i1 @fcmp_sqrt_zero_ult_nonzero(half %x) {
%cmp = fcmp ult half %sqrt, 1.000000e+00
ret i1 %cmp
}
+
+; fabs(uitofp(a) - uitofp(b)) < 1.0 --> a == b
+define i1 @fabs_uitofp_sub_olt_one(i16 %x, i16 %y) {
+; CHECK-LABEL: @fabs_uitofp_sub_olt_one(
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i16 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = uitofp i16 %x to float
+ %fy = uitofp i16 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp olt float %abs, 1.0
+ ret i1 %cmp
+}
+
+; fabs(uitofp(a) - uitofp(b)) < 1.0 --> a == b
+define i1 @fabs_uitofp_sub_ult_one(i16 %x, i16 %y) {
+; CHECK-LABEL: @fabs_uitofp_sub_ult_one(
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i16 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = uitofp i16 %x to float
+ %fy = uitofp i16 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp ult float %abs, 1.0
+ ret i1 %cmp
+}
+
+define i1 @fabs_sitofp_sub_olt_one(i16 %x, i16 %y) {
+; CHECK-LABEL: @fabs_sitofp_sub_olt_one(
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i16 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = sitofp i16 %x to float
+ %fy = sitofp i16 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp olt float %abs, 1.0
+ ret i1 %cmp
+}
+
+define i1 @fabs_uitofp_sub_ule_one(i16 %x, i16 %y) {
+; CHECK-LABEL: @fabs_uitofp_sub_ule_one(
+; CHECK-NEXT: [[FX:%.*]] = uitofp i16 [[X:%.*]] to float
+; CHECK-NEXT: [[FY:%.*]] = uitofp i16 [[Y:%.*]] to float
+; CHECK-NEXT: [[SUB:%.*]] = fsub float [[FX]], [[FY]]
+; CHECK-NEXT: [[ABS:%.*]] = call float @llvm.fabs.f32(float [[SUB]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ABS]], 1.000000e+00
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = uitofp i16 %x to float
+ %fy = uitofp i16 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp ule float %abs, 1.0
+ ret i1 %cmp
+}
+
+define i1 @fabs_sitofp_sub_ole_one(i16 %x, i16 %y) {
+; CHECK-LABEL: @fabs_sitofp_sub_ole_one(
+; CHECK-NEXT: [[FX:%.*]] = sitofp i16 [[X:%.*]] to float
+; CHECK-NEXT: [[FY:%.*]] = sitofp i16 [[Y:%.*]] to float
+; CHECK-NEXT: [[SUB:%.*]] = fsub float [[FX]], [[FY]]
+; CHECK-NEXT: [[ABS:%.*]] = call float @llvm.fabs.f32(float [[SUB]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ABS]], 1.000000e+00
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = sitofp i16 %x to float
+ %fy = sitofp i16 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp ole float %abs, 1.0
+ ret i1 %cmp
+}
+
+define i1 @fabs_sitofp_sub_ogt_half(i16 %x, i16 %y) {
+; CHECK-LABEL: @fabs_sitofp_sub_ogt_half(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ne i16 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = sitofp i16 %x to float
+ %fy = sitofp i16 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp ogt float %abs, 0.5
+ ret i1 %cmp
+}
+
+define i1 @fabs_sitofp_sub_oge_one(i16 %x, i16 %y) {
+; CHECK-LABEL: @fabs_sitofp_sub_oge_one(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ne i16 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = sitofp i16 %x to float
+ %fy = sitofp i16 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp oge float %abs, 1.0
+ ret i1 %cmp
+}
+
+; negative tests
+
+define i1 @fabs_uitofp_sub_olt_two_no_fold(i16 %x, i16 %y) {
+; CHECK-LABEL: @fabs_uitofp_sub_olt_two_no_fold(
+; CHECK-NEXT: [[FX:%.*]] = uitofp i16 [[X:%.*]] to float
+; CHECK-NEXT: [[FY:%.*]] = uitofp i16 [[Y:%.*]] to float
+; CHECK-NEXT: [[SUB:%.*]] = fsub float [[FX]], [[FY]]
+; CHECK-NEXT: [[ABS:%.*]] = call float @llvm.fabs.f32(float [[SUB]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ABS]], 2.000000e+00
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = uitofp i16 %x to float
+ %fy = uitofp i16 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp olt float %abs, 2.0
+ ret i1 %cmp
+}
+
+define i1 @fabs_sitofp_sub_olt_one_i32_no_fold(i32 %x, i32 %y) {
+; CHECK-LABEL: @fabs_sitofp_sub_olt_one_i32_no_fold(
+; CHECK-NEXT: [[FX:%.*]] = sitofp i32 [[X:%.*]] to float
+; CHECK-NEXT: [[FY:%.*]] = sitofp i32 [[Y:%.*]] to float
+; CHECK-NEXT: [[SUB:%.*]] = fsub float [[FX]], [[FY]]
+; CHECK-NEXT: [[ABS:%.*]] = call float @llvm.fabs.f32(float [[SUB]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ABS]], 1.000000e+00
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = sitofp i32 %x to float
+ %fy = sitofp i32 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp olt float %abs, 1.0
+ ret i1 %cmp
+}
+
+; For StrictGt, C ought to be strictly less than 1.0
+define i1 @fabs_sitofp_sub_ogt_one(i16 %x, i16 %y) {
+; CHECK-LABEL: @fabs_sitofp_sub_ogt_one(
+; CHECK-NEXT: [[FX:%.*]] = sitofp i16 [[X:%.*]] to float
+; CHECK-NEXT: [[FY:%.*]] = sitofp i16 [[Y:%.*]] to float
+; CHECK-NEXT: [[SUB:%.*]] = fsub float [[FX]], [[FY]]
+; CHECK-NEXT: [[ABS:%.*]] = call float @llvm.fabs.f32(float [[SUB]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ABS]], 1.000000e+00
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = sitofp i16 %x to float
+ %fy = sitofp i16 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp ogt float %abs, 1.0
+ ret i1 %cmp
+}
+
+define i1 @fabs_argstype_mismatch(i16 %x, i32 %y) {
+; CHECK-LABEL: @fabs_argstype_mismatch(
+; CHECK-NEXT: [[FY:%.*]] = sitofp i16 [[Y:%.*]] to float
+; CHECK-NEXT: [[FY1:%.*]] = sitofp i32 [[Y1:%.*]] to float
+; CHECK-NEXT: [[SUB:%.*]] = fsub float [[FY]], [[FY1]]
+; CHECK-NEXT: [[ABS:%.*]] = call float @llvm.fabs.f32(float [[SUB]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ABS]], 1.000000e+00
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %fx = sitofp i16 %x to float
+ %fy = sitofp i32 %y to float
+ %sub = fsub float %fx, %fy
+ %abs = call float @llvm.fabs.f32(float %sub)
+ %cmp = fcmp ogt float %abs, 1.0
+ ret i1 %cmp
+}
+
+; negative test for canBeCastedExactlyIntToFP()
+
+define i1 @fabs_no_fold_i32_half(i32 %a, i32 %b) {
+; CHECK-LABEL: @fabs_no_fold_i32_half(
+; CHECK-NEXT: [[FA:%.*]] = uitofp i32 [[A:%.*]] to half
+; CHECK-NEXT: [[FB:%.*]] = uitofp i32 [[B:%.*]] to half
+; CHECK-NEXT: [[SUB:%.*]] = fsub half [[FA]], [[FB]]
+; CHECK-NEXT: [[ABS:%.*]] = call half @llvm.fabs.f16(half [[SUB]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp olt half [[ABS]], 0xH3C00
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+
+ %fa = uitofp i32 %a to half
+ %fb = uitofp i32 %b to half
+ %sub = fsub half %fa, %fb
+ %abs = call half @llvm.fabs.f16(half %sub)
+ %cmp = fcmp olt half %abs, 1.0
+ ret i1 %cmp
+}
+
+; Vector case, unsigned fold
+define <2 x i1> @fabs_uitofp_sub_vec_olt_one(<2 x i16> %x, <2 x i16> %y) {
+; CHECK-LABEL: @fabs_uitofp_sub_vec_olt_one(
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq <2 x i16> [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret <2 x i1> [[CMP]]
+;
+ %fx = uitofp <2 x i16> %x to <2 x float>
+ %fy = uitofp <2 x i16> %y to <2 x float>
+ %sub = fsub <2 x float> %fx, %fy
+ %abs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %sub)
+ %cmp = fcmp olt <2 x float> %abs, splat (float 1.0)
+ ret <2 x i1> %cmp
+}
+
+; Vector case, signed fold
+define <2 x i1> @fabs_sitofp_sub_vec_ult_one(<2 x i16> %x, <2 x i16> %y) {
+; CHECK-LABEL: @fabs_sitofp_sub_vec_ult_one(
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq <2 x i16> [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret <2 x i1> [[CMP]]
+;
+ %fx = sitofp <2 x i16> %x to <2 x float>
+ %fy = sitofp <2 x i16> %y to <2 x float>
+ %sub = fsub <2 x float> %fx, %fy
+ %abs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %sub)
+ %cmp = fcmp ult <2 x float> %abs, splat (float 1.0)
+ ret <2 x i1> %cmp
+}
+
+; Vector case, exactness test with small mantissa FP type
+define <2 x i1> @fabs_uitofp_sub_vec_half_no_fold(<2 x i32> %x, <2 x i32> %y) {
+; CHECK-LABEL: @fabs_uitofp_sub_vec_half_no_fold(
+; CHECK-NEXT: [[FX:%.*]] = uitofp <2 x i32> [[X:%.*]] to <2 x half>
+; CHECK-NEXT: [[FY:%.*]] = uitofp <2 x i32> [[Y:%.*]] to <2 x half>
+; CHECK-NEXT: [[SUB:%.*]] = fsub <2 x half> [[FX]], [[FY]]
+; CHECK-NEXT: [[ABS:%.*]] = call <2 x half> @llvm.fabs.v2f16(<2 x half> [[SUB]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp olt <2 x half> [[ABS]], splat (half 0xH3C00)
+; CHECK-NEXT: ret <2 x i1> [[CMP]]
+;
+ %fx = uitofp <2 x i32> %x to <2 x half>
+ %fy = uitofp <2 x i32> %y to <2 x half>
+ %sub = fsub <2 x half> %fx, %fy
+ %abs = call <2 x half> @llvm.fabs.v2f16(<2 x half> %sub)
+ %cmp = fcmp olt <2 x half> %abs, splat (half 0xH3C00)
+ ret <2 x i1> %cmp
+}
+
+; Vector case, no fold due to failed exactness
+define <2 x i1> @fabs_uitofp_sub_vec_bf16_no_fold(<2 x i16> %x, <2 x i16> %y) {
+; CHECK-LABEL: @fabs_uitofp_sub_vec_bf16_no_fold(
+; CHECK-NEXT: [[FX:%.*]] = uitofp <2 x i16> [[X:%.*]] to <2 x bfloat>
+; CHECK-NEXT: [[FY:%.*]] = uitofp <2 x i16> [[Y:%.*]] to <2 x bfloat>
+; CHECK-NEXT: [[SUB:%.*]] = fsub <2 x bfloat> [[FX]], [[FY]]
+; CHECK-NEXT: [[ABS:%.*]] = call <2 x bfloat> @llvm.fabs.v2bf16(<2 x bfloat> [[SUB]])
+; CHECK-NEXT: [[CMP:%.*]] = fcmp olt <2 x bfloat> [[ABS]], splat (bfloat 0xR3F80)
+; CHECK-NEXT: ret <2 x i1> [[CMP]]
+;
+ %fx = uitofp <2 x i16> %x to <2 x bfloat>
+ %fy = uitofp <2 x i16> %y to <2 x bfloat>
+ %sub = fsub <2 x bfloat> %fx, %fy
+ %abs = call <2 x bfloat> @llvm.fabs.v2bf16(<2 x bfloat> %sub)
+ %cmp = fcmp olt <2 x bfloat> %abs, splat (bfloat 0xR3F80)
+ ret <2 x i1> %cmp
+}
More information about the llvm-commits
mailing list