This is an archive of the discontinued LLVM Phabricator instance.

Differential D139895

InstCombine: Fold is.fpclass (fneg x) into the test mask
ClosedPublic

Authored by arsenm on Dec 12 2022, 4:53 PM.

Details

Reviewers
sepavloff
andrew.w.kaylor
jcranmer-intel
foad
cameron.mcinally

Diff Detail

Event Timeline

arsenm created this revision.Dec 12 2022, 4:53 PM
Herald added a project: Restricted Project. · View Herald TranscriptDec 12 2022, 4:53 PM
Herald added a subscriber: hiraditya. · View Herald Transcript
arsenm requested review of this revision.Dec 12 2022, 4:53 PM
Herald added a project: Restricted Project. · View Herald TranscriptDec 12 2022, 4:53 PM
Herald added a subscriber: wdng. · View Herald Transcript
Harbormaster completed remote builds in B202720: Diff 482310.Dec 12 2022, 4:54 PM
foad accepted this revision.Dec 13 2022, 5:48 AM

LGTM. Could do the same kind of thing with abs.

This revision is now accepted and ready to land.Dec 13 2022, 5:48 AM
foad added a comment.Dec 13 2022, 6:02 AM
In D139895#3991686, @foad wrote:

Could do the same kind of thing with abs.

I've just seen D139903!

arsenm added a parent revision: D137811: InstCombine: Perform basic isnan combines on llvm.is.fpclass.Dec 16 2022, 7:11 AM
jcranmer-intel accepted this revision.Dec 20 2022, 8:35 AM
arsenm closed this revision.Feb 5 2023, 5:10 AM

a520851d1286edee59449f2d90bd04a982e54f8d

Herald added a subscriber: StephenFan. · View Herald TranscriptFeb 5 2023, 5:10 AM

Revision Contents

PathSize
llvm/
lib/
Transforms/
InstCombine/
25 lines
test/
Transforms/
InstCombine/
151 lines

Diff 482310

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

Show First 20 Lines • Show All 821 Lines • ▼ Show 20 Lines
Instruction *InstCombinerImpl::foldIntrinsicIsFPClass(IntrinsicInst &II) { Instruction *InstCombinerImpl::foldIntrinsicIsFPClass(IntrinsicInst &II) {
Value *Src0 = II.getArgOperand(0); Value *Src0 = II.getArgOperand(0);
Value *Src1 = II.getArgOperand(1); Value *Src1 = II.getArgOperand(1);
const ConstantInt *CMask = cast<ConstantInt>(Src1); const ConstantInt *CMask = cast<ConstantInt>(Src1);
uint32_t Mask = CMask->getZExtValue(); uint32_t Mask = CMask->getZExtValue();
const bool IsStrict = II.isStrictFP(); const bool IsStrict = II.isStrictFP();
Value *FNegSrc;
if (match(Src0, m_FNeg(m_Value(FNegSrc)))) {
// is.fpclass (fneg x), mask -> is.fpclass x, (fneg mask)
unsigned NewMask = Mask & fcNan;
if (Mask & fcNegInf)
NewMask |= fcPosInf;
if (Mask & fcNegNormal)
NewMask |= fcPosNormal;
if (Mask & fcNegSubnormal)
NewMask |= fcPosSubnormal;
if (Mask & fcNegZero)
NewMask |= fcPosZero;
if (Mask & fcPosZero)
NewMask |= fcNegZero;
if (Mask & fcPosSubnormal)
NewMask |= fcNegSubnormal;
if (Mask & fcPosNormal)
NewMask |= fcNegNormal;
if (Mask & fcPosInf)
NewMask |= fcNegInf;
II.setArgOperand(1, ConstantInt::get(Src1->getType(), NewMask));
return replaceOperand(II, 0, FNegSrc);
}
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,058 Lines • ▼ Show 20 Lines;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 1023) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 1023)
ret i1 %class ret i1 %class
} }
; -> snan ; -> snan
define i1 @test_class_fneg_snan(float %arg) { define i1 @test_class_fneg_snan(float %arg) {
; CHECK-LABEL: @test_class_fneg_snan( ; CHECK-LABEL: @test_class_fneg_snan(
; CHECK-NEXT: [[FNEG:%.*]] = fneg 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 [[FNEG]], i32 1)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 1) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 1)
ret i1 %class ret i1 %class
} }
; -> qnan ; -> qnan
define i1 @test_class_fneg_qnan(float %arg) { define i1 @test_class_fneg_qnan(float %arg) {
; CHECK-LABEL: @test_class_fneg_qnan( ; CHECK-LABEL: @test_class_fneg_qnan(
; CHECK-NEXT: [[FNEG:%.*]] = fneg 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 [[FNEG]], i32 2)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 2) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 2)
ret i1 %class ret i1 %class
} }
; -> posinf ; -> posinf
define i1 @test_class_fneg_neginf(float %arg) { define i1 @test_class_fneg_neginf(float %arg) {
; CHECK-LABEL: @test_class_fneg_neginf( ; CHECK-LABEL: @test_class_fneg_neginf(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 512)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 4)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 4) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 4)
ret i1 %class ret i1 %class
} }
; -> posnormal ; -> posnormal
define i1 @test_class_fneg_negnormal(float %arg) { define i1 @test_class_fneg_negnormal(float %arg) {
; CHECK-LABEL: @test_class_fneg_negnormal( ; CHECK-LABEL: @test_class_fneg_negnormal(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 256)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 8)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 8) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 8)
ret i1 %class ret i1 %class
} }
; -> possubnormal ; -> possubnormal
define i1 @test_class_fneg_negsubnormal(float %arg) { define i1 @test_class_fneg_negsubnormal(float %arg) {
; CHECK-LABEL: @test_class_fneg_negsubnormal( ; CHECK-LABEL: @test_class_fneg_negsubnormal(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 128)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 16)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 16) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 16)
ret i1 %class ret i1 %class
} }
; -> poszero ; -> poszero
define i1 @test_class_fneg_negzero(float %arg) { define i1 @test_class_fneg_negzero(float %arg) {
; CHECK-LABEL: @test_class_fneg_negzero( ; CHECK-LABEL: @test_class_fneg_negzero(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 64)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 32)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 32) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 32)
ret i1 %class ret i1 %class
} }
; -> negzero ; -> negzero
define i1 @test_class_fneg_poszero(float %arg) { define i1 @test_class_fneg_poszero(float %arg) {
; CHECK-LABEL: @test_class_fneg_poszero( ; CHECK-LABEL: @test_class_fneg_poszero(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 32)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 64)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 64) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 64)
ret i1 %class ret i1 %class
} }
; -> negsubnormal ; -> negsubnormal
define i1 @test_class_fneg_possubnormal(float %arg) { define i1 @test_class_fneg_possubnormal(float %arg) {
; CHECK-LABEL: @test_class_fneg_possubnormal( ; CHECK-LABEL: @test_class_fneg_possubnormal(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 16)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 128)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 128) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 128)
ret i1 %class ret i1 %class
} }
; -> negnormal ; -> negnormal
define i1 @test_class_fneg_posnormal(float %arg) { define i1 @test_class_fneg_posnormal(float %arg) {
; CHECK-LABEL: @test_class_fneg_posnormal( ; CHECK-LABEL: @test_class_fneg_posnormal(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 8)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 256)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 256) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 256)
ret i1 %class ret i1 %class
} }
; -> neginf ; -> neginf
define i1 @test_class_fneg_posinf(float %arg) { define i1 @test_class_fneg_posinf(float %arg) {
; CHECK-LABEL: @test_class_fneg_posinf( ; CHECK-LABEL: @test_class_fneg_posinf(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 4)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 512)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 512) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 512)
ret i1 %class ret i1 %class
} }
; -> qnan|snan ; -> qnan|snan
Show All 16 Lines;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 1020) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 1020)
ret i1 %class ret i1 %class
} }
; -> normal ; -> normal
define i1 @test_class_fneg_normal(float %arg) { define i1 @test_class_fneg_normal(float %arg) {
; CHECK-LABEL: @test_class_fneg_normal( ; CHECK-LABEL: @test_class_fneg_normal(
; CHECK-NEXT: [[FNEG:%.*]] = fneg 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 [[FNEG]], i32 264)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 264) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 264)
ret i1 %class ret i1 %class
} }
; -> zero ; -> zero
define i1 @test_class_fneg_zero(float %arg) { define i1 @test_class_fneg_zero(float %arg) {
; ;
; CHECK-LABEL: @test_class_fneg_zero( ; CHECK-LABEL: @test_class_fneg_zero(
; CHECK-NEXT: [[FNEG:%.*]] = fneg 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 [[FNEG]], i32 96)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 96) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 96)
ret i1 %class ret i1 %class
} }
; -> subnormal ; -> subnormal
define i1 @test_class_fneg_subnormal(float %arg) { define i1 @test_class_fneg_subnormal(float %arg) {
; ;
; CHECK-LABEL: @test_class_fneg_subnormal( ; CHECK-LABEL: @test_class_fneg_subnormal(
; CHECK-NEXT: [[FNEG:%.*]] = fneg 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 [[FNEG]], i32 144)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 144) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 144)
ret i1 %class ret i1 %class
} }
; -> normal|pinf ; -> normal|pinf
define i1 @test_class_fneg_normal_neginf(float %arg) { define i1 @test_class_fneg_normal_neginf(float %arg) {
; CHECK-LABEL: @test_class_fneg_normal_neginf( ; CHECK-LABEL: @test_class_fneg_normal_neginf(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 776)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 268)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 268) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 268)
ret i1 %class ret i1 %class
} }
; -> normal|ninf ; -> normal|ninf
define i1 @test_class_fneg_normal_pinf(float %arg) { define i1 @test_class_fneg_normal_pinf(float %arg) {
; CHECK-LABEL: @test_class_fneg_normal_pinf( ; CHECK-LABEL: @test_class_fneg_normal_pinf(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 268)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 776)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 776) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 776)
ret i1 %class ret i1 %class
} }
; -> pinf|nnormal|pnormal|nzero ; -> pinf|nnormal|pnormal|nzero
define i1 @test_class_fneg_neginf_posnormal_negsubnormal_poszero(float %arg) { define i1 @test_class_fneg_neginf_posnormal_negsubnormal_poszero(float %arg) {
; CHECK-LABEL: @test_class_fneg_neginf_posnormal_negsubnormal_poszero( ; CHECK-LABEL: @test_class_fneg_neginf_posnormal_negsubnormal_poszero(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 680)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 340)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 340) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 340)
ret i1 %class ret i1 %class
} }
; -> pinf|nnormal|psubnormal|negzero|snan ; -> pinf|nnormal|psubnormal|negzero|snan
define i1 @test_class_fneg_neginf_posnormal_negsubnormal_poszero_snan(float %arg) { define i1 @test_class_fneg_neginf_posnormal_negsubnormal_poszero_snan(float %arg) {
; CHECK-LABEL: @test_class_fneg_neginf_posnormal_negsubnormal_poszero_snan( ; CHECK-LABEL: @test_class_fneg_neginf_posnormal_negsubnormal_poszero_snan(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 681)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 341)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 341) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 341)
ret i1 %class ret i1 %class
} }
; pinf|negnormal|psubnormal|negzero|qnan ; pinf|negnormal|psubnormal|negzero|qnan
define i1 @test_class_fneg_neginf_posnormal_negsubnormal_poszero_qnan(float %arg) { define i1 @test_class_fneg_neginf_posnormal_negsubnormal_poszero_qnan(float %arg) {
; CHECK-LABEL: @test_class_fneg_neginf_posnormal_negsubnormal_poszero_qnan( ; CHECK-LABEL: @test_class_fneg_neginf_posnormal_negsubnormal_poszero_qnan(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 682)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 342)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 342) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 342)
ret i1 %class ret i1 %class
} }
; -> pinf | nnormal|psubnormal|nzero|nan ; -> pinf | nnormal|psubnormal|nzero|nan
define i1 @test_class_fneg_neginf_posnormal_negsubnormal_poszero_nan(float %arg) { define i1 @test_class_fneg_neginf_posnormal_negsubnormal_poszero_nan(float %arg) {
; CHECK-LABEL: @test_class_fneg_neginf_posnormal_negsubnormal_poszero_nan( ; CHECK-LABEL: @test_class_fneg_neginf_posnormal_negsubnormal_poszero_nan(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 683)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 343)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 343) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 343)
ret i1 %class ret i1 %class
} }
; -> ninf|pnormal|negsubnormal|pzero ; -> ninf|pnormal|negsubnormal|pzero
define i1 @test_class_fneg_posinf_negnormal_possubnormal_negzero(float %arg) { define i1 @test_class_fneg_posinf_negnormal_possubnormal_negzero(float %arg) {
; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero( ; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 340)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 680)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 680) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 680)
ret i1 %class ret i1 %class
} }
; -> ninf|pnormal|negsubnormal|pzero|snan ; -> ninf|pnormal|negsubnormal|pzero|snan
define i1 @test_class_fneg_posinf_negnormal_possubnormal_negzero_snan(float %arg) { define i1 @test_class_fneg_posinf_negnormal_possubnormal_negzero_snan(float %arg) {
; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero_snan( ; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero_snan(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 341)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 681)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 681) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 681)
ret i1 %class ret i1 %class
} }
; -> ninf|pnormal|negsubnormal|pzero|qnan ; -> ninf|pnormal|negsubnormal|pzero|qnan
define i1 @test_class_fneg_posinf_negnormal_possubnormal_negzero_qnan(float %arg) { define i1 @test_class_fneg_posinf_negnormal_possubnormal_negzero_qnan(float %arg) {
; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero_qnan( ; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero_qnan(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 342)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 682)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 682) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 682)
ret i1 %class ret i1 %class
} }
; -> ninf|pnormal|negsubnormal|pzero ; -> ninf|pnormal|negsubnormal|pzero
define i1 @test_class_fneg_posinf_negnormal_possubnormal_negzero_nan(float %arg) { define i1 @test_class_fneg_posinf_negnormal_possubnormal_negzero_nan(float %arg) {
; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero_nan( ; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero_nan(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 343)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 683)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 683) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 683)
ret i1 %class ret i1 %class
} }
; strictfp doesn't matter ; strictfp doesn't matter
; -> ninf|pnormal|negsubnormal|pzero|snan ; -> ninf|pnormal|negsubnormal|pzero|snan
define i1 @test_class_fneg_posinf_negnormal_possubnormal_negzero_snan_strictfp(float %arg) strictfp { define i1 @test_class_fneg_posinf_negnormal_possubnormal_negzero_snan_strictfp(float %arg) strictfp {
; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero_snan_strictfp( ; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero_snan_strictfp(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG:%.*]], i32 341) #[[ATTR2]]
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 681) #[[ATTR2]]
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 681) strictfp %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 681) strictfp
ret i1 %class ret i1 %class
} }
; multiple uses don't matter ; multiple uses don't matter
define i1 @test_class_fneg_multiple_use_fneg(float %arg, ptr %ptr) { define i1 @test_class_fneg_multiple_use_fneg(float %arg, ptr %ptr) {
; CHECK-LABEL: @test_class_fneg_multiple_use_fneg( ; CHECK-LABEL: @test_class_fneg_multiple_use_fneg(
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[ARG:%.*]]
; CHECK-NEXT: store float [[FNEG]], ptr [[PTR:%.*]], align 4 ; CHECK-NEXT: store float [[FNEG]], ptr [[PTR:%.*]], align 4
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG]], i32 682) ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG]], i32 342)
; CHECK-NEXT: ret i1 [[CLASS]] ; CHECK-NEXT: ret i1 [[CLASS]]
; ;
%fneg = fneg float %arg %fneg = fneg float %arg
store float %fneg, ptr %ptr store float %fneg, ptr %ptr
%class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 682) %class = call i1 @llvm.is.fpclass.f32(float %fneg, i32 682)
ret i1 %class ret i1 %class
} }
define <2 x i1> @test_class_fneg_posinf_negnormal_possubnormal_negzero_nan_vector(<2 x float> %arg) { define <2 x i1> @test_class_fneg_posinf_negnormal_possubnormal_negzero_nan_vector(<2 x float> %arg) {
; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero_nan_vector( ; CHECK-LABEL: @test_class_fneg_posinf_negnormal_possubnormal_negzero_nan_vector(
; CHECK-NEXT: [[FNEG:%.*]] = fneg <2 x float> [[ARG:%.*]] ; CHECK-NEXT: [[CLASS:%.*]] = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> [[ARG:%.*]], i32 343)
; CHECK-NEXT: [[CLASS:%.*]] = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> [[FNEG]], i32 683)
; CHECK-NEXT: ret <2 x i1> [[CLASS]] ; CHECK-NEXT: ret <2 x i1> [[CLASS]]
; ;
%fneg = fneg <2 x float> %arg %fneg = fneg <2 x float> %arg
%class = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> %fneg, i32 683) %class = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> %fneg, i32 683)
ret <2 x i1> %class ret <2 x i1> %class
} }
; --------------------------------------------------------------------- ; ---------------------------------------------------------------------
▲ Show 20 Lines • Show All 378 Lines • ▼ Show 20 Lines;
%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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 1)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 2)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 512)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_FABS]], i32 4)
; 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 256)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_FABS]], i32 8)
; 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 128)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_FABS]], i32 16)
; 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 64)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_FABS]], i32 32)
; 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 32)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 16)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 8)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 4)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 512) %class = call i1 @llvm.is.fpclass.f32(float %fneg.fabs, i32 512)
ret i1 %class ret i1 %class
} }
Show All 17 Lines;
%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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 264)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 96)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 144)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 776)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 268)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 680)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 681)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 682)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 683)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 340)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 341)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 342)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 343)
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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 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: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FABS]], i32 341) #[[ATTR2]]
; CHECK-NEXT: [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[FNEG_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)
%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 [[FNEG_FABS]], i32 682) ; 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
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
} }
Show All 18 Lines