This is an archive of the discontinued LLVM Phabricator instance.

Differential D140296

ValueTracking: Teach CannotBeOrderedLessThanZero about rounding intrinsics
ClosedPublic

Authored by arsenm on Dec 19 2022, 5:28 AM.

Details

Reviewers
sepavloff
jcranmer-intel
nlopes
andrew.w.kaylor
kpn
Summary

These should obviously preserve the sign although the variety of these
always confuses me.

Diff Detail

Unit TestsFailed

TimeTest
60,060 msx64 debian > libFuzzer.libFuzzer::fuzzer-leak.test
60,040 msx64 debian > libFuzzer.libFuzzer::minimize_crash.test

Event Timeline

arsenm created this revision.Dec 19 2022, 5:28 AM
Herald added a project: Restricted Project. · View Herald TranscriptDec 19 2022, 5:28 AM
Herald added a subscriber: hiraditya. · View Herald Transcript
arsenm requested review of this revision.Dec 19 2022, 5:28 AM
Herald added a project: Restricted Project. · View Herald TranscriptDec 19 2022, 5:28 AM
Herald added a subscriber: wdng. · View Herald Transcript
Harbormaster completed remote builds in B203885: Diff 483925.Dec 19 2022, 6:50 AM
arsenm added a comment.Jan 5 2023, 7:59 AM

ping

arsenm added a comment.Jan 12 2023, 5:14 AM

ping

jcranmer-intel accepted this revision.Jan 13 2023, 1:35 PM
This revision is now accepted and ready to land.Jan 13 2023, 1:35 PM
arsenm closed this revision.Jan 15 2023, 6:45 AM

c663b8c4295e70ccfde9a88cb22d0d0b42d5288f

Revision Contents

PathSize
llvm/
lib/
Analysis/
8 lines
test/
Transforms/
InstSimplify/
185 lines

Diff 483925

llvm/lib/Analysis/ValueTracking.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,656 Lines • ▼ Show 20 Linesstatic bool cannotBeOrderedLessThanZeroImpl(const Value *V,
case Instruction::Call: case Instruction::Call:
const auto *CI = cast<CallInst>(I); const auto *CI = cast<CallInst>(I);
Intrinsic::ID IID = getIntrinsicForCallSite(*CI, TLI); Intrinsic::ID IID = getIntrinsicForCallSite(*CI, TLI);
switch (IID) { switch (IID) {
default: default:
break; break;
case Intrinsic::canonicalize: case Intrinsic::canonicalize:
case Intrinsic::arithmetic_fence: case Intrinsic::arithmetic_fence:
case Intrinsic::floor:
case Intrinsic::ceil:
case Intrinsic::trunc:
case Intrinsic::rint:
case Intrinsic::nearbyint:
case Intrinsic::round:
case Intrinsic::roundeven:
case Intrinsic::fptrunc_round:
return cannotBeOrderedLessThanZeroImpl(I->getOperand(0), TLI, SignBitOnly, Depth + 1); return cannotBeOrderedLessThanZeroImpl(I->getOperand(0), TLI, SignBitOnly, Depth + 1);
case Intrinsic::maxnum: { case Intrinsic::maxnum: {
Value *V0 = I->getOperand(0), *V1 = I->getOperand(1); Value *V0 = I->getOperand(0), *V1 = I->getOperand(1);
auto isPositiveNum = [&](Value *V) { auto isPositiveNum = [&](Value *V) {
if (SignBitOnly) { if (SignBitOnly) {
// With SignBitOnly, this is tricky because the result of // With SignBitOnly, this is tricky because the result of
// maxnum(+0.0, -0.0) is unspecified. Just check if the operand is // maxnum(+0.0, -0.0) is unspecified. Just check if the operand is
// a constant strictly greater than 0.0. // a constant strictly greater than 0.0.
▲ Show 20 Lines • Show All 3,795 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/floating-point-arithmetic.ll

Show First 20 Lines • Show All 271 Lines • ▼ Show 20 Lines;
%4 = call float @sqrtf(float %3) %4 = call float @sqrtf(float %3)
%5 = call float @sqrtf(float %4) %5 = call float @sqrtf(float %4)
%6 = call float @sqrtf(float %5) %6 = call float @sqrtf(float %5)
%7 = fadd float %6, 0.0 %7 = fadd float %6, 0.0
ret float %7 ret float %7
} }
declare float @llvm.fabs.f32(float) declare float @llvm.fabs.f32(float)
declare double @llvm.fabs.f64(double)
declare float @llvm.canonicalize.f32(float) declare float @llvm.canonicalize.f32(float)
declare float @llvm.floor.f32(float)
declare float @llvm.ceil.f32(float)
declare float @llvm.trunc.f32(float)
declare float @llvm.rint.f32(float)
declare float @llvm.nearbyint.f32(float)
declare float @llvm.round.f32(float)
declare float @llvm.roundeven.f32(float)
declare float @llvm.fptrunc.round.f32.f64(double, metadata)
declare float @llvm.arithmetic.fence.f32(float) declare float @llvm.arithmetic.fence.f32(float)
declare float @llvm.copysign.f32(float, float) declare float @llvm.copysign.f32(float, float)
declare <2 x float> @llvm.fabs.v2f32(<2 x float>) declare <2 x float> @llvm.fabs.v2f32(<2 x float>)
declare float @llvm.sqrt.f32(float) declare float @llvm.sqrt.f32(float)
declare float @llvm.maxnum.f32(float, float) declare float @llvm.maxnum.f32(float, float)
define float @fabs_select_positive_constants(i32 %c) { define float @fabs_select_positive_constants(i32 %c) {
; CHECK-LABEL: @fabs_select_positive_constants( ; CHECK-LABEL: @fabs_select_positive_constants(
▲ Show 20 Lines • Show All 696 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[UNKNOWN:%.*]], float [[UNKNOWN_SIGN:%.*]]) ; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[UNKNOWN:%.*]], float [[UNKNOWN_SIGN:%.*]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp nnan oge float [[COPYSIGN]], 0.000000e+00 ; CHECK-NEXT: [[CMP:%.*]] = fcmp nnan oge float [[COPYSIGN]], 0.000000e+00
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%copysign = call float @llvm.copysign.f32(float %unknown, float %unknown.sign) %copysign = call float @llvm.copysign.f32(float %unknown, float %unknown.sign)
%cmp = fcmp nnan oge float %copysign, 0.0 %cmp = fcmp nnan oge float %copysign, 0.0
ret i1 %cmp ret i1 %cmp
} }
; https://alive2.llvm.org/ce/z/Y-EyY3
define i1 @floor_known_positive(float %a) {
; CHECK-LABEL: @floor_known_positive(
; CHECK-NEXT: ret i1 true
;
%fabs = call float @llvm.fabs.f32(float %a)
%known.positive = call float @llvm.floor.f32(float %fabs)
%cmp = fcmp nnan oge float %known.positive, 0.0
ret i1 %cmp
}
define i1 @floor_unknown_positive(float %unknown) {
; CHECK-LABEL: @floor_unknown_positive(
; CHECK-NEXT: [[OP:%.*]] = call float @llvm.floor.f32(float [[UNKNOWN:%.*]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp nnan oge float [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[CMP]]
;
%op = call float @llvm.floor.f32(float %unknown)
%cmp = fcmp nnan oge float %op, 0.0
ret i1 %cmp
}
; https://alive2.llvm.org/ce/z/3tBUoW
define i1 @ceil_known_positive(float %a) {
; CHECK-LABEL: @ceil_known_positive(
; CHECK-NEXT: ret i1 true
;
%fabs = call float @llvm.fabs.f32(float %a)
%known.positive = call float @llvm.ceil.f32(float %fabs)
%cmp = fcmp nnan oge float %known.positive, 0.0
ret i1 %cmp
}
define i1 @ceil_unknown_positive(float %unknown) {
; CHECK-LABEL: @ceil_unknown_positive(
; CHECK-NEXT: [[OP:%.*]] = call float @llvm.ceil.f32(float [[UNKNOWN:%.*]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp nnan oge float [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[CMP]]
;
%op = call float @llvm.ceil.f32(float %unknown)
%cmp = fcmp nnan oge float %op, 0.0
ret i1 %cmp
}
; https://alive2.llvm.org/ce/z/RbyJPX
define i1 @trunc_known_positive(float %a) {
; CHECK-LABEL: @trunc_known_positive(
; CHECK-NEXT: ret i1 true
;
%fabs = call float @llvm.fabs.f32(float %a)
%known.positive = call float @llvm.trunc.f32(float %fabs)
%cmp = fcmp nnan oge float %known.positive, 0.0
ret i1 %cmp
}
define i1 @trunc_unknown_positive(float %unknown) {
; CHECK-LABEL: @trunc_unknown_positive(
; CHECK-NEXT: [[OP:%.*]] = call float @llvm.trunc.f32(float [[UNKNOWN:%.*]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp nnan oge float [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[CMP]]
;
%op = call float @llvm.trunc.f32(float %unknown)
%cmp = fcmp nnan oge float %op, 0.0
ret i1 %cmp
}
; https://alive2.llvm.org/ce/z/bjC2Jm
define i1 @rint_known_positive(float %a) {
; CHECK-LABEL: @rint_known_positive(
; CHECK-NEXT: ret i1 true
;
%fabs = call float @llvm.fabs.f32(float %a)
%known.positive = call float @llvm.rint.f32(float %fabs)
%cmp = fcmp nnan oge float %known.positive, 0.0
ret i1 %cmp
}
define i1 @rint_unknown_positive(float %unknown) {
; CHECK-LABEL: @rint_unknown_positive(
; CHECK-NEXT: [[OP:%.*]] = call float @llvm.rint.f32(float [[UNKNOWN:%.*]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp nnan oge float [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[CMP]]
;
%op = call float @llvm.rint.f32(float %unknown)
%cmp = fcmp nnan oge float %op, 0.0
ret i1 %cmp
}
; https://alive2.llvm.org/ce/z/dFiL9n
define i1 @nearbyint_known_positive(float %a) {
; CHECK-LABEL: @nearbyint_known_positive(
; CHECK-NEXT: ret i1 true
;
%fabs = call float @llvm.fabs.f32(float %a)
%known.positive = call float @llvm.nearbyint.f32(float %fabs)
%cmp = fcmp nnan oge float %known.positive, 0.0
ret i1 %cmp
}
define i1 @nearbyint_unknown_positive(float %unknown) {
; CHECK-LABEL: @nearbyint_unknown_positive(
; CHECK-NEXT: [[OP:%.*]] = call float @llvm.nearbyint.f32(float [[UNKNOWN:%.*]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp nnan oge float [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[CMP]]
;
%op = call float @llvm.nearbyint.f32(float %unknown)
%cmp = fcmp nnan oge float %op, 0.0
ret i1 %cmp
}
; https://alive2.llvm.org/ce/z/kPhS-d
define i1 @round_known_positive(float %a) {
; CHECK-LABEL: @round_known_positive(
; CHECK-NEXT: ret i1 true
;
%fabs = call float @llvm.fabs.f32(float %a)
%known.positive = call float @llvm.round.f32(float %fabs)
%cmp = fcmp nnan oge float %known.positive, 0.0
ret i1 %cmp
}
define i1 @round_unknown_positive(float %unknown) {
; CHECK-LABEL: @round_unknown_positive(
; CHECK-NEXT: [[OP:%.*]] = call float @llvm.round.f32(float [[UNKNOWN:%.*]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp nnan oge float [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[CMP]]
;
%op = call float @llvm.round.f32(float %unknown)
%cmp = fcmp nnan oge float %op, 0.0
ret i1 %cmp
}
; https://alive2.llvm.org/ce/z/Z_tfsu
define i1 @roundeven_known_positive(float %a) {
; CHECK-LABEL: @roundeven_known_positive(
; CHECK-NEXT: ret i1 true
;
%fabs = call float @llvm.fabs.f32(float %a)
%known.positive = call float @llvm.roundeven.f32(float %fabs)
%cmp = fcmp nnan oge float %known.positive, 0.0
ret i1 %cmp
}
define i1 @roundeven_unknown_positive(float %unknown) {
; CHECK-LABEL: @roundeven_unknown_positive(
; CHECK-NEXT: [[OP:%.*]] = call float @llvm.roundeven.f32(float [[UNKNOWN:%.*]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp nnan oge float [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[CMP]]
;
%op = call float @llvm.roundeven.f32(float %unknown)
%cmp = fcmp nnan oge float %op, 0.0
ret i1 %cmp
}
define i1 @fptrunc_round_known_positive(double %a) {
; CHECK-LABEL: @fptrunc_round_known_positive(
; CHECK-NEXT: ret i1 true
;
%fabs = call double @llvm.fabs.f64(double %a)
%known.positive = call float @llvm.fptrunc.round.f32.f64(double %fabs, metadata !"round.downward")
%cmp = fcmp nnan oge float %known.positive, 0.0
ret i1 %cmp
}
define i1 @fptrunc_round_unknown_positive(double %unknown) {
; CHECK-LABEL: @fptrunc_round_unknown_positive(
; CHECK-NEXT: [[OP:%.*]] = call float @llvm.fptrunc.round.f32.f64(double [[UNKNOWN:%.*]], metadata !"round.downward")
; CHECK-NEXT: [[CMP:%.*]] = fcmp nnan oge float [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[CMP]]
;
%op = call float @llvm.fptrunc.round.f32.f64(double %unknown, metadata !"round.downward")
%cmp = fcmp nnan oge float %op, 0.0
ret i1 %cmp
}