[llvm] r344796 - [ConstantFolding] Constant fold minimum and maximum intrinsics
Thomas Lively via llvm-commits
llvm-commits at lists.llvm.org
Fri Oct 19 11:15:32 PDT 2018
Author: tlively
Date: Fri Oct 19 11:15:32 2018
New Revision: 344796
URL: http://llvm.org/viewvc/llvm-project?rev=344796&view=rev
Log:
[ConstantFolding] Constant fold minimum and maximum intrinsics
Summary: Depends on D52764
Reviewers: aheejin, dschuff
Subscribers: llvm-commits
Differential Revision: https://reviews.llvm.org/D52765
Added:
llvm/trunk/test/Analysis/ConstantFolding/min-max.ll
Modified:
llvm/trunk/lib/Analysis/ConstantFolding.cpp
Modified: llvm/trunk/lib/Analysis/ConstantFolding.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ConstantFolding.cpp?rev=344796&r1=344795&r2=344796&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/ConstantFolding.cpp (original)
+++ llvm/trunk/lib/Analysis/ConstantFolding.cpp Fri Oct 19 11:15:32 2018
@@ -1363,6 +1363,8 @@ bool llvm::canConstantFoldCallTo(Immutab
case Intrinsic::fabs:
case Intrinsic::minnum:
case Intrinsic::maxnum:
+ case Intrinsic::minimum:
+ case Intrinsic::maximum:
case Intrinsic::log:
case Intrinsic::log2:
case Intrinsic::log10:
@@ -1912,6 +1914,18 @@ Constant *ConstantFoldScalarCall(StringR
return ConstantFP::get(Ty->getContext(), maxnum(C1, C2));
}
+ if (IntrinsicID == Intrinsic::minimum) {
+ const APFloat &C1 = Op1->getValueAPF();
+ const APFloat &C2 = Op2->getValueAPF();
+ return ConstantFP::get(Ty->getContext(), minimum(C1, C2));
+ }
+
+ if (IntrinsicID == Intrinsic::maximum) {
+ const APFloat &C1 = Op1->getValueAPF();
+ const APFloat &C2 = Op2->getValueAPF();
+ return ConstantFP::get(Ty->getContext(), maximum(C1, C2));
+ }
+
if (!TLI)
return nullptr;
if ((Name == "pow" && TLI->has(LibFunc_pow)) ||
Added: llvm/trunk/test/Analysis/ConstantFolding/min-max.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/ConstantFolding/min-max.ll?rev=344796&view=auto
==============================================================================
--- llvm/trunk/test/Analysis/ConstantFolding/min-max.ll (added)
+++ llvm/trunk/test/Analysis/ConstantFolding/min-max.ll Fri Oct 19 11:15:32 2018
@@ -0,0 +1,136 @@
+; RUN: opt -instcombine -S -o - %s | FileCheck %s
+; Tests that constant folding of min and max operations works as expected.
+
+declare float @llvm.minnum.f32(float, float)
+declare float @llvm.maxnum.f32(float, float)
+declare <4 x float> @llvm.minnum.v4f32(<4 x float>, <4 x float>)
+declare <4 x float> @llvm.maxnum.v4f32(<4 x float>, <4 x float>)
+
+declare float @llvm.minimum.f32(float, float)
+declare float @llvm.maximum.f32(float, float)
+declare <4 x float> @llvm.minimum.v4f32(<4 x float>, <4 x float>)
+declare <4 x float> @llvm.maximum.v4f32(<4 x float>, <4 x float>)
+
+; CHECK: define float @minnum_float() {
+define float @minnum_float() {
+ ; CHECK-NEXT: ret float 5.000000e+00
+ %1 = call float @llvm.minnum.f32(float 5.0, float 42.0)
+ ret float %1
+}
+
+; Check that minnum constant folds to propagate non-NaN or smaller argument
+; CHECK: define <4 x float> @minnum_float_vec() {
+define <4 x float> @minnum_float_vec() {
+ ; CHECK-NEXT: ret <4 x float> <float 0x7FF8000000000000, float 5.000000e+00,
+ ; CHECK-SAME: float 4.200000e+01, float 5.000000e+00>
+ %1 = call <4 x float> @llvm.minnum.v4f32(
+ <4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000, float 42., float 42.>,
+ <4 x float> <float 0x7FF8000000000000, float 5., float 0x7FF8000000000000, float 5.>
+ )
+ ret <4 x float> %1
+}
+
+; Check that minnum constant folds to propagate one of its argument zeros
+; CHECK: define <4 x float> @minnum_float_zeros_vec() {
+define <4 x float> @minnum_float_zeros_vec() {
+ ; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float {{-?}}0.000000e+00,
+ ; CHECK-SAME: float {{-?}}0.000000e+00, float -0.000000e+00>
+ %1 = call <4 x float> @llvm.minnum.v4f32(
+ <4 x float> <float 0.0, float -0.0, float 0.0, float -0.0>,
+ <4 x float> <float 0.0, float 0.0, float -0.0, float -0.0>
+ )
+ ret <4 x float> %1
+}
+
+; CHECK: define float @maxnum_float() {
+define float @maxnum_float() {
+ ; CHECK-NEXT: ret float 4.200000e+01
+ %1 = call float @llvm.maxnum.f32(float 5.0, float 42.0)
+ ret float %1
+}
+
+; Check that maxnum constant folds to propagate non-NaN or greater argument
+; CHECK: define <4 x float> @maxnum_float_vec() {
+define <4 x float> @maxnum_float_vec() {
+ ; CHECK-NEXT: ret <4 x float> <float 0x7FF8000000000000, float 5.000000e+00,
+ ; CHECK-SAME: float 4.200000e+01, float 4.200000e+01>
+ %1 = call <4 x float> @llvm.maxnum.v4f32(
+ <4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000, float 42., float 42.>,
+ <4 x float> <float 0x7FF8000000000000, float 5., float 0x7FF8000000000000, float 5.>
+ )
+ ret <4 x float> %1
+}
+
+; Check that maxnum constant folds to propagate one of its argument zeros
+; CHECK: define <4 x float> @maxnum_float_zeros_vec() {
+define <4 x float> @maxnum_float_zeros_vec() {
+ ; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float {{-?}}0.000000e+00,
+ ; CHECK-SAME: float {{-?}}0.000000e+00, float -0.000000e+00>
+ %1 = call <4 x float> @llvm.maxnum.v4f32(
+ <4 x float> <float 0.0, float -0.0, float 0.0, float -0.0>,
+ <4 x float> <float 0.0, float 0.0, float -0.0, float -0.0>
+ )
+ ret <4 x float> %1
+}
+
+; CHECK: define float @minimum_float() {
+define float @minimum_float() {
+ ; CHECK-NEXT: ret float 5.000000e+00
+ %1 = call float @llvm.minimum.f32(float 5.0, float 42.0)
+ ret float %1
+}
+
+; Check that minimum propagates its NaN or smaller argument
+; CHECK: define <4 x float> @minimum_float_vec() {
+define <4 x float> @minimum_float_vec() {
+ ; CHECK-NEXT: ret <4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000,
+ ; CHECK-SAME: float 0x7FF8000000000000, float 5.000000e+00>
+ %1 = call <4 x float> @llvm.minimum.v4f32(
+ <4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000, float 42., float 42.>,
+ <4 x float> <float 0x7FF8000000000000, float 5., float 0x7FF8000000000000, float 5.>
+ )
+ ret <4 x float> %1
+}
+
+; Check that minimum treats -0.0 as smaller than 0.0 while constant folding
+; CHECK: define <4 x float> @minimum_float_zeros_vec() {
+define <4 x float> @minimum_float_zeros_vec() {
+ ; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float -0.000000e+00,
+ ; CHECK-SAME: float -0.000000e+00, float -0.000000e+00>
+ %1 = call <4 x float> @llvm.minimum.v4f32(
+ <4 x float> <float 0.0, float -0.0, float 0.0, float -0.0>,
+ <4 x float> <float 0.0, float 0.0, float -0.0, float -0.0>
+ )
+ ret <4 x float> %1
+}
+
+; CHECK: define float @maximum_float() {
+define float @maximum_float() {
+ ; CHECK-NEXT: ret float 4.200000e+01
+ %1 = call float @llvm.maximum.f32(float 5.0, float 42.0)
+ ret float %1
+}
+
+; Check that maximum propagates its NaN or greater argument
+; CHECK: define <4 x float> @maximum_float_vec() {
+define <4 x float> @maximum_float_vec() {
+ ; CHECK-NEXT: ret <4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000,
+ ; CHECK-SAME: float 0x7FF8000000000000, float 4.200000e+01>
+ %1 = call <4 x float> @llvm.maximum.v4f32(
+ <4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000, float 42., float 42.>,
+ <4 x float> <float 0x7FF8000000000000, float 5., float 0x7FF8000000000000, float 5.>
+ )
+ ret <4 x float> %1
+}
+
+; Check that maximum treats -0.0 as smaller than 0.0 while constant folding
+; CHECK: define <4 x float> @maximum_float_zeros_vec() {
+define <4 x float> @maximum_float_zeros_vec() {
+ ; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float 0.000000e+00,
+ ; CHECK-SAME: float 0.000000e+00, float -0.000000e+00>
+ %1 = call <4 x float> @llvm.maximum.v4f32(
+ <4 x float> <float 0.0, float -0.0, float 0.0, float -0.0>,
+ <4 x float> <float 0.0, float 0.0, float -0.0, float -0.0>
+ )
+ ret <4 x float> %1
+}
More information about the llvm-commits
mailing list