This is an archive of the discontinued LLVM Phabricator instance.

Differential D139903

InstCombine: Fold is.fpclass (fabs x), mask -> is.fpclass x, (fabs mask)
ClosedPublic

Authored by arsenm on Dec 12 2022, 6:47 PM.

Details

Reviewers
foad
sepavloff
spatel
kpn
andrew.w.kaylor
jcranmer-intel

Diff Detail

Revision Contents

PathSize
llvm/
lib/
Transforms/
InstCombine/
16 lines
test/
Transforms/
InstCombine/
162 lines

Diff 482334

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

Show First 20 Lines • Show All 846 Lines • ▼ Show 20 Lines if (Mask & fcPosNormal)
NewMask |= fcNegNormal; NewMask |= fcNegNormal;
if (Mask & fcPosInf) if (Mask & fcPosInf)
NewMask |= fcNegInf; NewMask |= fcNegInf;
II.setArgOperand(1, ConstantInt::get(Src1->getType(), NewMask)); II.setArgOperand(1, ConstantInt::get(Src1->getType(), NewMask));
return replaceOperand(II, 0, FNegSrc); return replaceOperand(II, 0, FNegSrc);
} }
Value *FAbsSrc;
if (match(Src0, m_FAbs(m_Value(FAbsSrc)))) {
unsigned NewMask = Mask & fcNan;
if (Mask & fcPosZero)
NewMask |= fcZero;
if (Mask & fcPosSubnormal)
NewMask |= fcSubnormal;
if (Mask & fcPosNormal)
NewMask |= fcNormal;
if (Mask & fcPosInf)
NewMask |= fcInf;
II.setArgOperand(1, ConstantInt::get(Src1->getType(), NewMask));
return replaceOperand(II, 0, FAbsSrc);
}
if (Mask == fcNan && !IsStrict) { if (Mask == fcNan && !IsStrict) {
// Equivalent of isnan. Replace with standard fcmp if we don't care about FP // Equivalent of isnan. Replace with standard fcmp if we don't care about FP
// exceptions. // exceptions.
Value *FCmp = Builder.CreateIsNaN(Src0); Value *FCmp = Builder.CreateIsNaN(Src0);
FCmp->takeName(&II); FCmp->takeName(&II);
return replaceInstUsesWith(II, FCmp); return replaceInstUsesWith(II, FCmp);
} }
▲ Show 20 Lines • Show All 3,020 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/is_fpclass.ll

Show First 20 Lines • Show All 1,395 Lines • ▼ Show 20 Lines;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 1023) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 1023)
ret i1 %class ret i1 %class
} }
; -> snan ; -> snan
define i1 @test_class_fabs_snan(float %arg) { define i1 @test_class_fabs_snan(float %arg) {
; CHECK-LABEL: @test_class_fabs_snan( ; CHECK-LABEL: @test_class_fabs_snan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 1)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 1)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 1) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 1)
ret i1 %class ret i1 %class
} }
; -> qnan ; -> qnan
define i1 @test_class_fabs_qnan(float %arg) { define i1 @test_class_fabs_qnan(float %arg) {
; CHECK-LABEL: @test_class_fabs_qnan( ; CHECK-LABEL: @test_class_fabs_qnan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 2)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 2)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 2) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 2)
ret i1 %class ret i1 %class
} }
; -> false ; -> false
define i1 @test_class_fabs_neginf(float %arg) { define i1 @test_class_fabs_neginf(float %arg) {
; CHECK-LABEL: @test_class_fabs_neginf( ; CHECK-LABEL: @test_class_fabs_neginf(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 4)
; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 4) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 4)
ret i1 %class ret i1 %class
} }
; -> false ; -> false
define i1 @test_class_fabs_negnormal(float %arg) { define i1 @test_class_fabs_negnormal(float %arg) {
; CHECK-LABEL: @test_class_fabs_negnormal( ; CHECK-LABEL: @test_class_fabs_negnormal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 8)
; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 8) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 8)
ret i1 %class ret i1 %class
} }
; -> false ; -> false
define i1 @test_class_fabs_negsubnormal(float %arg) { define i1 @test_class_fabs_negsubnormal(float %arg) {
; CHECK-LABEL: @test_class_fabs_negsubnormal( ; CHECK-LABEL: @test_class_fabs_negsubnormal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 16)
; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 16) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 16)
ret i1 %class ret i1 %class
} }
; -> false ; -> false
define i1 @test_class_fabs_negzero(float %arg) { define i1 @test_class_fabs_negzero(float %arg) {
; CHECK-LABEL: @test_class_fabs_negzero( ; CHECK-LABEL: @test_class_fabs_negzero(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 32)
; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 32) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 32)
ret i1 %class ret i1 %class
} }
; -> poszero ; -> poszero
define i1 @test_class_fabs_poszero(float %arg) { define i1 @test_class_fabs_poszero(float %arg) {
; CHECK-LABEL: @test_class_fabs_poszero( ; CHECK-LABEL: @test_class_fabs_poszero(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 96)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 64)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 64) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 64)
ret i1 %class ret i1 %class
} }
; -> possubnormal ; -> possubnormal
define i1 @test_class_fabs_possubnormal(float %arg) { define i1 @test_class_fabs_possubnormal(float %arg) {
; CHECK-LABEL: @test_class_fabs_possubnormal( ; CHECK-LABEL: @test_class_fabs_possubnormal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 144)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 128)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 128) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 128)
ret i1 %class ret i1 %class
} }
; -> posnormal ; -> posnormal
define i1 @test_class_fabs_posnormal(float %arg) { define i1 @test_class_fabs_posnormal(float %arg) {
; CHECK-LABEL: @test_class_fabs_posnormal( ; CHECK-LABEL: @test_class_fabs_posnormal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 264)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 256)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 256) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 256)
ret i1 %class ret i1 %class
} }
; -> posinf ; -> posinf
define i1 @test_class_fabs_posinf(float %arg) { define i1 @test_class_fabs_posinf(float %arg) {
; CHECK-LABEL: @test_class_fabs_posinf( ; CHECK-LABEL: @test_class_fabs_posinf(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 516)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 512)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 512) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 512)
ret i1 %class ret i1 %class
} }
; -> qnan|snan ; -> qnan|snan
Show All 16 Lines;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 1020) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 1020)
ret i1 %class ret i1 %class
} }
; -> posnormal ; -> posnormal
define i1 @test_class_fabs_normal(float %arg) { define i1 @test_class_fabs_normal(float %arg) {
; CHECK-LABEL: @test_class_fabs_normal( ; CHECK-LABEL: @test_class_fabs_normal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 264)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 264)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 264) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 264)
ret i1 %class ret i1 %class
} }
; -> poszero ; -> poszero
define i1 @test_class_fabs_zero(float %arg) { define i1 @test_class_fabs_zero(float %arg) {
; CHECK-LABEL: @test_class_fabs_zero( ; CHECK-LABEL: @test_class_fabs_zero(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 96)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 96)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 96) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 96)
ret i1 %class ret i1 %class
} }
; -> possubnormal ; -> possubnormal
define i1 @test_class_fabs_subnormal(float %arg) { define i1 @test_class_fabs_subnormal(float %arg) {
; CHECK-LABEL: @test_class_fabs_subnormal( ; CHECK-LABEL: @test_class_fabs_subnormal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 144)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 144)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 144) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 144)
ret i1 %class ret i1 %class
} }
; -> posnormal ; -> posnormal
define i1 @test_class_fabs_normal_neginf(float %arg) { define i1 @test_class_fabs_normal_neginf(float %arg) {
; CHECK-LABEL: @test_class_fabs_normal_neginf( ; CHECK-LABEL: @test_class_fabs_normal_neginf(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 264)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 268)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 268) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 268)
ret i1 %class ret i1 %class
} }
; -> pnormal|pinf ; -> pnormal|pinf
define i1 @test_class_fabs_normal_pinf(float %arg) { define i1 @test_class_fabs_normal_pinf(float %arg) {
; CHECK-LABEL: @test_class_fabs_normal_pinf( ; CHECK-LABEL: @test_class_fabs_normal_pinf(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 780)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 776)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 776) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 776)
ret i1 %class ret i1 %class
} }
; -> pnormal|pzero ; -> pnormal|pzero
define i1 @test_class_fabs_neginf_posnormal_negsubnormal_poszero(float %arg) { define i1 @test_class_fabs_neginf_posnormal_negsubnormal_poszero(float %arg) {
; CHECK-LABEL: @test_class_fabs_neginf_posnormal_negsubnormal_poszero( ; CHECK-LABEL: @test_class_fabs_neginf_posnormal_negsubnormal_poszero(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 360)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 340)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 340) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 340)
ret i1 %class ret i1 %class
} }
; -> pnormal|pzero|snan ; -> pnormal|pzero|snan
define i1 @test_class_fabs_neginf_posnormal_negsubnormal_poszero_snan(float %arg) { define i1 @test_class_fabs_neginf_posnormal_negsubnormal_poszero_snan(float %arg) {
; CHECK-LABEL: @test_class_fabs_neginf_posnormal_negsubnormal_poszero_snan( ; CHECK-LABEL: @test_class_fabs_neginf_posnormal_negsubnormal_poszero_snan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 361)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 341)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 341) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 341)
ret i1 %class ret i1 %class
} }
; -> negnormal|pzero|qnan ; -> negnormal|pzero|qnan
define i1 @test_class_fabs_neginf_posnormal_negsubnormal_poszero_qnan(float %arg) { define i1 @test_class_fabs_neginf_posnormal_negsubnormal_poszero_qnan(float %arg) {
; CHECK-LABEL: @test_class_fabs_neginf_posnormal_negsubnormal_poszero_qnan( ; CHECK-LABEL: @test_class_fabs_neginf_posnormal_negsubnormal_poszero_qnan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 362)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 342)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 342) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 342)
ret i1 %class ret i1 %class
} }
; -> pnormal|pzero|nan ; -> pnormal|pzero|nan
define i1 @test_class_fabs_neginf_posnormal_negsubnormal_poszero_nan(float %arg) { define i1 @test_class_fabs_neginf_posnormal_negsubnormal_poszero_nan(float %arg) {
; CHECK-LABEL: @test_class_fabs_neginf_posnormal_negsubnormal_poszero_nan( ; CHECK-LABEL: @test_class_fabs_neginf_posnormal_negsubnormal_poszero_nan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 363)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 343)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 343) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 343)
ret i1 %class ret i1 %class
} }
; -> ninf|pnormal|negsubnormal|pzero ; -> ninf|pnormal|negsubnormal|pzero
define i1 @test_class_fabs_posinf_negnormal_possubnormal_negzero(float %arg) { define i1 @test_class_fabs_posinf_negnormal_possubnormal_negzero(float %arg) {
; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero( ; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 660)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 680)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 680) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 680)
ret i1 %class ret i1 %class
} }
; -> pinf|psubnormal|snan ; -> pinf|psubnormal|snan
define i1 @test_class_fabs_posinf_negnormal_possubnormal_negzero_snan(float %arg) { define i1 @test_class_fabs_posinf_negnormal_possubnormal_negzero_snan(float %arg) {
; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero_snan( ; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero_snan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 661)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 681)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 681) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 681)
ret i1 %class ret i1 %class
} }
; -> pinf|psubnormal|qnan ; -> pinf|psubnormal|qnan
define i1 @test_class_fabs_posinf_negnormal_possubnormal_negzero_qnan(float %arg) { define i1 @test_class_fabs_posinf_negnormal_possubnormal_negzero_qnan(float %arg) {
; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero_qnan( ; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero_qnan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 662)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 682)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 682) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 682)
ret i1 %class ret i1 %class
} }
; -> pinf|psubnormal|nan ; -> pinf|psubnormal|nan
define i1 @test_class_fabs_posinf_negnormal_possubnormal_negzero_nan(float %arg) { define i1 @test_class_fabs_posinf_negnormal_possubnormal_negzero_nan(float %arg) {
; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero_nan( ; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero_nan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 663)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 683)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 683) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 683)
ret i1 %class ret i1 %class
} }
; strictfp doesn't matter ; strictfp doesn't matter
; -> pinf|psubnormal|snan ; -> pinf|psubnormal|snan
define i1 @test_class_fabs_posinf_negnormal_possubnormal_negzero_snan_strictfp(float %arg) strictfp { define i1 @test_class_fabs_posinf_negnormal_possubnormal_negzero_snan_strictfp(float %arg) strictfp {
; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero_snan_strictfp( ; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero_snan_strictfp(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 661) #[[ATTR2]]
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 681) #[[ATTR2]]
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 681) strictfp %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 681) strictfp
ret i1 %class ret i1 %class
} }
; multiple uses don't matter ; multiple uses don't matter
define i1 @test_class_fabs_multiple_use_fabs(float %arg, ptr %ptr) { define i1 @test_class_fabs_multiple_use_fabs(float %arg, ptr %ptr) {
; CHECK-LABEL: @test_class_fabs_multiple_use_fabs( ; CHECK-LABEL: @test_class_fabs_multiple_use_fabs(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: store float [[FABS]], ptr [[PTR:%.*]], align 4 ; CHECK-NEXT: store float [[FABS]], ptr [[PTR:%.*]], align 4
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 682) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG]], i32 662)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
store float %fabs, ptr %ptr store float %fabs, ptr %ptr
%class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 682) %class = call i1 @llvm.is.fpclass.f32(float %fabs, i32 682)
ret i1 %class ret i1 %class
} }
define <2 x i1> @test_class_fabs_posinf_negnormal_possubnormal_negzero_nan_vector(<2 x float> %arg) { define <2 x i1> @test_class_fabs_posinf_negnormal_possubnormal_negzero_nan_vector(<2 x float> %arg) {
; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero_nan_vector( ; CHECK-LABEL: @test_class_fabs_posinf_negnormal_possubnormal_negzero_nan_vector(
; CHECK-NEXT: [[FABS:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> [[ARG:%.*]], i32 663)
; CHECK-NEXT: [[CLASS:%.*]] = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> [[FABS]], i32 683)
; CHECK-NEXT: ret <2 x i1> [[CLASS]] ; CHECK-NEXT: ret <2 x i1> [[CLASS]]
; ;
%fabs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %arg) %fabs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %arg)
%class = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> %fabs, i32 683) %class = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> %fabs, i32 683)
ret <2 x i1> %class ret <2 x i1> %class
} }
; --------------------------------------------------------------------- ; ---------------------------------------------------------------------
Show All 17 Lines;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 1023) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 1023)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_snan(float %arg) { define i1 @test_class_fneg_fabs_snan(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_snan( ; CHECK-LABEL: @test_class_fneg_fabs_snan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 1)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 1)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 1) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 1)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_qnan(float %arg) { define i1 @test_class_fneg_fabs_qnan(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_qnan( ; CHECK-LABEL: @test_class_fneg_fabs_qnan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 2)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 2)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 2) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 2)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_neginf(float %arg) { define i1 @test_class_fneg_fabs_neginf(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_neginf( ; CHECK-LABEL: @test_class_fneg_fabs_neginf(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 516)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 512)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 4) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 4)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_negnormal(float %arg) { define i1 @test_class_fneg_fabs_negnormal(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_negnormal( ; CHECK-LABEL: @test_class_fneg_fabs_negnormal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 264)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 256)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 8) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 8)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_negsubnormal(float %arg) { define i1 @test_class_fneg_fabs_negsubnormal(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_negsubnormal( ; CHECK-LABEL: @test_class_fneg_fabs_negsubnormal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 144)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 128)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 16) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 16)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_negzero(float %arg) { define i1 @test_class_fneg_fabs_negzero(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_negzero( ; CHECK-LABEL: @test_class_fneg_fabs_negzero(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 96)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 64)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 32) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 32)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_poszero(float %arg) { define i1 @test_class_fneg_fabs_poszero(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_poszero( ; CHECK-LABEL: @test_class_fneg_fabs_poszero(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 32)
; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 64) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 64)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_possubnormal(float %arg) { define i1 @test_class_fneg_fabs_possubnormal(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_possubnormal( ; CHECK-LABEL: @test_class_fneg_fabs_possubnormal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 16)
; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 128) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 128)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_posnormal(float %arg) { define i1 @test_class_fneg_fabs_posnormal(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_posnormal( ; CHECK-LABEL: @test_class_fneg_fabs_posnormal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 8)
; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 256) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 256)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_posinf(float %arg) { define i1 @test_class_fneg_fabs_posinf(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_posinf( ; CHECK-LABEL: @test_class_fneg_fabs_posinf(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 4)
; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 512) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 512)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_isnan(float %arg) { define i1 @test_class_fneg_fabs_isnan(float %arg) {
Show All 15 Lines;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 1020) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 1020)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_normal(float %arg) { define i1 @test_class_fneg_fabs_normal(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_normal( ; CHECK-LABEL: @test_class_fneg_fabs_normal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 264)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 264)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 264) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 264)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_zero(float %arg) { define i1 @test_class_fneg_fabs_zero(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_zero( ; CHECK-LABEL: @test_class_fneg_fabs_zero(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 96)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 96)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 96) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 96)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_subnormal(float %arg) { define i1 @test_class_fneg_fabs_subnormal(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_subnormal( ; CHECK-LABEL: @test_class_fneg_fabs_subnormal(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 144)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 144)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 144) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 144)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_normal_neginf(float %arg) { define i1 @test_class_fneg_fabs_normal_neginf(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_normal_neginf( ; CHECK-LABEL: @test_class_fneg_fabs_normal_neginf(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 780)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 776)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 268) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 268)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_normal_pinf(float %arg) { define i1 @test_class_fneg_fabs_normal_pinf(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_normal_pinf( ; CHECK-LABEL: @test_class_fneg_fabs_normal_pinf(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 264)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 268)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 776) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 776)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero(float %arg) { define i1 @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero( ; CHECK-LABEL: @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 660)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 680)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 340) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 340)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_snan(float %arg) { define i1 @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_snan(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_snan( ; CHECK-LABEL: @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_snan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 661)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 681)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 341) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 341)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_qnan(float %arg) { define i1 @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_qnan(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_qnan( ; CHECK-LABEL: @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_qnan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 662)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 682)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 342) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 342)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_nan(float %arg) { define i1 @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_nan(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_nan( ; CHECK-LABEL: @test_class_fneg_fabs_neginf_posnormal_negsubnormal_poszero_nan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 663)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 683)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 343) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 343)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero(float %arg) { define i1 @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero( ; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 360)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 340)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 680) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 680)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_snan(float %arg) { define i1 @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_snan(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_snan( ; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_snan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 361)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 341)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 681) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 681)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_qnan(float %arg) { define i1 @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_qnan(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_qnan( ; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_qnan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 362)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 342)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 682) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 682)
ret i1 %class ret i1 %class
} }
define i1 @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_nan(float %arg) { define i1 @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_nan(float %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_nan( ; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_nan(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 363)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 343)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 683) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 683)
ret i1 %class ret i1 %class
} }
; strictfp doesn't matter ; strictfp doesn't matter
define i1 @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_snan_strictfp(float %arg) strictfp { define i1 @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_snan_strictfp(float %arg) strictfp {
; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_snan_strictfp( ; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_snan_strictfp(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 361) #[[ATTR2]]
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 341) #[[ATTR2]]
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 681) strictfp %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 681) strictfp
ret i1 %class ret i1 %class
} }
; multiple uses don't matter ; multiple uses don't matter
define i1 @test_class_fneg_fabs_multiple_use_fabs(float %arg, ptr %ptr) { define i1 @test_class_fneg_fabs_multiple_use_fabs(float %arg, ptr %ptr) {
; CHECK-LABEL: @test_class_fneg_fabs_multiple_use_fabs( ; CHECK-LABEL: @test_class_fneg_fabs_multiple_use_fabs(
; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]]) ; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]]
; CHECK-NEXT: store float [[FNEG_FABS]], ptr [[PTR:%.*]], align 4 ; CHECK-NEXT: store float [[FNEG_FABS]], ptr [[PTR:%.*]], align 4
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 342) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG]], i32 362)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fabs = call float @llvm.fabs.f32(float %arg) %fabs = call float @llvm.fabs.f32(float %arg)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
store float %fneg.fabs, ptr %ptr store float %fneg.fabs, ptr %ptr
%class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 682) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 682)
ret i1 %class ret i1 %class
} }
define <2 x i1> @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_nan_vector(<2 x float> %arg) { define <2 x i1> @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_nan_vector(<2 x float> %arg) {
; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_nan_vector( ; CHECK-LABEL: @test_class_fneg_fabs_posinf_negnormal_possubnormal_negzero_nan_vector(
; CHECK-NEXT: [[FABS:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[ARG:%.*]]) ; CHECK-NEXT: [[CLASS:%.*]] = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> [[ARG:%.*]], i32 663)
; CHECK-NEXT: [[CLASS:%.*]] = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> [[FABS]], i32 683)
; CHECK-NEXT: ret <2 x i1> [[CLASS]] ; CHECK-NEXT: ret <2 x i1> [[CLASS]]
; ;
%fabs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %arg) %fabs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %arg)
%fneg.fabs = fneg <2 x float> %fabs %fneg.fabs = fneg <2 x float> %fabs
%class = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> %fabs, i32 683) %class = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> %fabs, i32 683)
ret <2 x i1> %class ret <2 x i1> %class
} }
declare i1 @llvm.is.fpclass.f32(float, i32 immarg) declare i1 @llvm.is.fpclass.f32(float, i32 immarg)
declare i1 @llvm.is.fpclass.f64(double, i32 immarg) declare i1 @llvm.is.fpclass.f64(double, i32 immarg)
declare <2 x i1> @llvm.is.fpclass.v2f32(<2 x float>, i32 immarg) declare <2 x i1> @llvm.is.fpclass.v2f32(<2 x float>, i32 immarg)
declare float @llvm.fabs.f32(float) declare float @llvm.fabs.f32(float)
declare <2 x float> @llvm.fabs.v2f32(<2 x float>) declare <2 x float> @llvm.fabs.v2f32(<2 x float>)