[ConstantFolding] Constant fold minimum and maximum intrinsics

[tlively]

Summary

Depends on D52764

[arsenm]

This is already done? See test/Transforms/InstCombine/{minnum,maxnum}.ll

[tlively]

In D52765#1252050, @arsenm wrote:

This is already done? See test/Transforms/InstCombine/{minnum,maxnum}.ll

This is for two proposed new intrinsics that have the draft IEEE 754-2018 semantics (NaN propagation and defined ordering of signed zeros) as opposed to minnum and maxnum's IEEE 754-2008 semantics.

[arsenm]

In D52765#1252050, @arsenm wrote:

This is already done? See test/Transforms/InstCombine/{minnum,maxnum}.ll

Turns out I can't read

[arsenm]

In D52765#1252052, @tlively wrote:

In D52765#1252050, @arsenm wrote:

This is already done? See test/Transforms/InstCombine/{minnum,maxnum}.ll

This is for two proposed new intrinsics that have the draft IEEE 754-2018 semantics (NaN propagation and defined ordering of signed zeros) as opposed to minnum and maxnum's IEEE 754-2008 semantics.

The minnum/mixnum intrinsics don't follow the IEEE 754-2008 NaN propagation rules

[tlively]

In D52765#1252057, @arsenm wrote:

In D52765#1252052, @tlively wrote:

In D52765#1252050, @arsenm wrote:

This is already done? See test/Transforms/InstCombine/{minnum,maxnum}.ll

This is for two proposed new intrinsics that have the draft IEEE 754-2018 semantics (NaN propagation and defined ordering of signed zeros) as opposed to minnum and maxnum's IEEE 754-2008 semantics.

The minnum/mixnum intrinsics don't follow the IEEE 754-2008 NaN propagation rules

Not regarding quiet NaNs and such, but they do return their non-NaN argument just like the min and max operations specified in IEEE 754-2008.

[aheejin]

test/Analysis/ConstantFolding/min-max.ll

14 ↗

(On Diff #167875)

Maybe add one or two line comments about what the expectations are for each test?

49 ↗

(On Diff #167875)

Maybe add tests with zeros for minnum and maxnum too to show they can't be constant folded?

[tlively]

• Add constant folding tests for minnum/maxnum on zeroes

[tlively]

test/Analysis/ConstantFolding/min-max.ll

49 ↗

(On Diff #167875)

Done, but showing that they can be constant folded. The new tests allow either positive or negative zero when both as passed as arguments.

[tlively]

• Add comments

[aheejin]

Thanks!

llvm/trunk/lib/Analysis/ConstantFolding.cpp

 
 bool llvm::canConstantFoldCallTo(ImmutableCallSite CS, const Function *F) {
   if (CS.isNoBuiltin() || CS.isStrictFP())
     return false;
   switch (F->getIntrinsicID()) {
   case Intrinsic::fabs:
   case Intrinsic::minnum:
   case Intrinsic::maxnum:
+  case Intrinsic::minimum:
+  case Intrinsic::maximum:
   case Intrinsic::log:
   case Intrinsic::log2:
   case Intrinsic::log10:
   case Intrinsic::exp:
   case Intrinsic::exp2:
   case Intrinsic::floor:
   case Intrinsic::ceil:
   case Intrinsic::sqrt:
if (auto *Op1 = dyn_cast<ConstantFP>(Operands[0])) {
         }
 
         if (IntrinsicID == Intrinsic::maxnum) {
           const APFloat &C1 = Op1->getValueAPF();
           const APFloat &C2 = Op2->getValueAPF();
           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)) ||
             (Name == "powf" && TLI->has(LibFunc_powf)) ||
             (Name == "__pow_finite" && TLI->has(LibFunc_pow_finite)) ||
             (Name == "__powf_finite" && TLI->has(LibFunc_powf_finite)))
           return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
         if ((Name == "fmod" && TLI->has(LibFunc_fmod)) ||

llvm/trunk/test/Analysis/ConstantFolding/min-max.ll

+; 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
+}