ConstantFolding: Constant fold denormal inputs to canonicalize for IEEE

[arsenm]

Summary

This makes it possible to use canonicalize to perform a dynamic check
for whether denormal flushing is enabled, which will fold out when the
denormal mode is known. Previously it would only fold if denormal
flushing were known enabled.

Not sure if this needs to filter the misbehaved types

[foad]

llvm/lib/Analysis/ConstantFolding.cpp

1979

You could still fold this case if Src is positive and output mode is PreserveSign or PositiveZero.

1982

DenormMode.Input == DenormalMode::Dynamic is false here.

[arsenm]

a09d9b42f16264980138a7bebd89f49b38c36fbd

llvm/lib/Analysis/ConstantFolding.cpp

static Constant *constantFoldCanonicalize(const Type *Ty, const CallBase *CI,
   // totally average number.
   if (Src.isNormal() || Src.isInfinity())
     return ConstantFP::get(CI->getContext(), Src);
 
   if (Src.isDenormal() && CI->getParent() && CI->getFunction()) {
     DenormalMode DenormMode =
         CI->getFunction()->getDenormalMode(Src.getSemantics());
 
-    // TODO: Should allow folding for pure IEEE.
     if (DenormMode == DenormalMode::getIEEE())
-      return nullptr;
+      return ConstantFP::get(CI->getContext(), Src);
 
     if (DenormMode.Input == DenormalMode::Dynamic)
       return nullptr;
 
     // If we know if either input or output is flushed, we can fold.
     if ((DenormMode.Input == DenormalMode::Dynamic &&
          DenormMode.Output == DenormalMode::IEEE) ||
         (DenormMode.Input == DenormalMode::IEEE &&
          DenormMode.Output == DenormalMode::Dynamic))
       return nullptr;
 
     bool IsPositive =
         (!Src.isNegative() || DenormMode.Input == DenormalMode::PositiveZero ||
          (DenormMode.Output == DenormalMode::PositiveZero &&

llvm/test/Transforms/InstSimplify/canonicalize.ll

 ; CHECK-NEXT:    ret <2 x float> poison
 ;
   %ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> poison)
   ret <2 x float> %ret
 }
 
 define float @canonicalize_denorm() {
 ; CHECK-LABEL: @canonicalize_denorm(
-; CHECK-NEXT:    [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0x380FFFFFC0000000)
-; CHECK-NEXT:    ret float [[RET]]
+; CHECK-NEXT:    ret float 0x380FFFFFC0000000
 ;
   %ret = call float @llvm.canonicalize.f32(float bitcast (i32 8388607 to float))
   ret float %ret
 }
 
 define float @canonicalize_pos_denorm_preserve_sign_output() "denormal-fp-math"="preserve-sign,ieee" {
 ; CHECK-LABEL: @canonicalize_pos_denorm_preserve_sign_output(
 ; CHECK-NEXT:    ret float 0.000000e+00

 ; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %ret = call double @llvm.canonicalize.f64(double 1.0)
   ret double %ret
 }
 
 define double @canonicalize_0x00000000000001_f64() {
 ; CHECK-LABEL: @canonicalize_0x00000000000001_f64(
-; CHECK-NEXT:    [[RET:%.*]] = call double @llvm.canonicalize.f64(double 4.940660e-324)
-; CHECK-NEXT:    ret double [[RET]]
+; CHECK-NEXT:    ret double 4.940660e-324
 ;
   %ret = call double @llvm.canonicalize.f64(double 0x00000000000001)
   ret double %ret
 }
 
 define double @canonicalize_inf_f64() {
 ; CHECK-LABEL: @canonicalize_inf_f64(
 ; CHECK-NEXT:    ret double 0x7FF0000000000000

 ; CHECK-NEXT:    ret half 0xH3C00
 ;
   %ret = call half @llvm.canonicalize.f16(half 1.0)
   ret half %ret
 }
 
 define half @canonicalize_0x0001_f16() {
 ; CHECK-LABEL: @canonicalize_0x0001_f16(
-; CHECK-NEXT:    [[RET:%.*]] = call half @llvm.canonicalize.f16(half 0xH0001)
-; CHECK-NEXT:    ret half [[RET]]
+; CHECK-NEXT:    ret half 0xH0001
 ;
   %ret = call half @llvm.canonicalize.f16(half 0xH0001)
   ret half %ret
 }
 
 define half @canonicalize_inf_f16() {
 ; CHECK-LABEL: @canonicalize_inf_f16(
 ; CHECK-NEXT:    ret half 0xH7C00

 ; CHECK-NEXT:    ret fp128 0xL00000000000000003FFF000000000000
 ;
   %ret = call fp128 @llvm.canonicalize.fp128(fp128 0xL00000000000000003FFF000000000000)
   ret fp128 %ret
 }
 
 define fp128 @canonicalize_0x00000000000000000000000000000001_fp128() {
 ; CHECK-LABEL: @canonicalize_0x00000000000000000000000000000001_fp128(
-; CHECK-NEXT:    [[RET:%.*]] = call fp128 @llvm.canonicalize.f128(fp128 0xL00000000000000000000000000000001)
-; CHECK-NEXT:    ret fp128 [[RET]]
+; CHECK-NEXT:    ret fp128 0xL00000000000000000000000000000001
 ;
   %ret = call fp128 @llvm.canonicalize.fp128(fp128 0xL00000000000000000000000000000001)
   ret fp128 %ret
 }
 
 define fp128 @canonicalize_inf_fp128() {
 ; CHECK-LABEL: @canonicalize_inf_fp128(
 ; CHECK-NEXT:    ret fp128 0xL00000000000000007FFF000000000000

 ; CHECK-NEXT:    ret bfloat 0xR3F80
 ;
   %ret = call bfloat @llvm.canonicalize.bf16(bfloat 1.0)
   ret bfloat %ret
 }
 
 define bfloat @canonicalize_0x0001_bf16() {
 ; CHECK-LABEL: @canonicalize_0x0001_bf16(
-; CHECK-NEXT:    [[RET:%.*]] = call bfloat @llvm.canonicalize.bf16(bfloat 0xR0001)
-; CHECK-NEXT:    ret bfloat [[RET]]
+; CHECK-NEXT:    ret bfloat 0xR0001
 ;
   %ret = call bfloat @llvm.canonicalize.bf16(bfloat 0xR0001)
   ret bfloat %ret
 }
 
 define bfloat @canonicalize_inf_bf16() {
 ; CHECK-LABEL: @canonicalize_inf_bf16(
 ; CHECK-NEXT:    ret bfloat 0xR7F80

 ; CHECK-LABEL: @canonicalize_neg1.0_ppcf128(
 ; CHECK-NEXT:    [[RET:%.*]] = call ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128 0xMBFF00000000000000000000000000000)
 ; CHECK-NEXT:    ret ppc_fp128 [[RET]]
 ;
   %ret = call ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128 0xMBFF00000000000000000000000000000)
   ret ppc_fp128 %ret
 }
 
+; --------------------------------------------------------------------
+; Test folds of using canonicalize + is.fpclass to inspect the denormal mode.
+; --------------------------------------------------------------------
+
+define i1 @is_poszero_daz_enabled_check_dynamic() "denormal-fp-math"="ieee,dynamic" {
+; CHECK-LABEL: @is_poszero_daz_enabled_check_dynamic(
+; CHECK-NEXT:    [[CANONICAL:%.*]] = call float @llvm.canonicalize.f32(float 0x36A0000000000000)
+; CHECK-NEXT:    [[IS_POS_ZERO:%.*]] = call i1 @llvm.is.fpclass.f32(float [[CANONICAL]], i32 64)
+; CHECK-NEXT:    ret i1 [[IS_POS_ZERO]]
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %is.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 64)
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_preserve_sign_daz_enabled_check_dynamic() "denormal-fp-math"="ieee,dynamic" {
+; CHECK-LABEL: @is_preserve_sign_daz_enabled_check_dynamic(
+; CHECK-NEXT:    [[CANONICAL:%.*]] = call float @llvm.canonicalize.f32(float 0xB6A0000000000000)
+; CHECK-NEXT:    [[IS_NEG_ZERO:%.*]] = call i1 @llvm.is.fpclass.f32(float [[CANONICAL]], i32 32)
+; CHECK-NEXT:    ret i1 [[IS_NEG_ZERO]]
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.neg.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 32)
+  ret i1 %is.neg.zero
+}
+
+define i1 @is_positive_zero_daz_enabled_check_dynamic() "denormal-fp-math"="ieee,dynamic" {
+; CHECK-LABEL: @is_positive_zero_daz_enabled_check_dynamic(
+; CHECK-NEXT:    [[CANONICAL:%.*]] = call float @llvm.canonicalize.f32(float 0xB6A0000000000000)
+; CHECK-NEXT:    [[IS_POS_ZERO:%.*]] = call i1 @llvm.is.fpclass.f32(float [[CANONICAL]], i32 64)
+; CHECK-NEXT:    ret i1 [[IS_POS_ZERO]]
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 64)
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_any_daz_enabled_check_dynamic() "denormal-fp-math"="ieee,dynamic" {
+; CHECK-LABEL: @is_any_daz_enabled_check_dynamic(
+; CHECK-NEXT:    [[CANONICAL:%.*]] = call float @llvm.canonicalize.f32(float 0xB6A0000000000000)
+; CHECK-NEXT:    [[IS_ANY_ZERO:%.*]] = call i1 @llvm.is.fpclass.f32(float [[CANONICAL]], i32 96)
+; CHECK-NEXT:    ret i1 [[IS_ANY_ZERO]]
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.any.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 96)
+  ret i1 %is.any.zero
+}
+
+define i1 @is_not_daz_enabled_check_dynamic() "denormal-fp-math"="ieee,dynamic" {
+; CHECK-LABEL: @is_not_daz_enabled_check_dynamic(
+; CHECK-NEXT:    [[CANONICAL:%.*]] = call float @llvm.canonicalize.f32(float 0x36A0000000000000)
+; CHECK-NEXT:    [[IS_NOT_POS_ZERO:%.*]] = call i1 @llvm.is.fpclass.f32(float [[CANONICAL]], i32 959)
+; CHECK-NEXT:    ret i1 [[IS_NOT_POS_ZERO]]
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %is.not.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 959)
+  ret i1 %is.not.pos.zero
+}
+
+define i1 @is_poszero_daz_enabled_check_ieee() "denormal-fp-math"="ieee,ieee" {
+; CHECK-LABEL: @is_poszero_daz_enabled_check_ieee(
+; CHECK-NEXT:    ret i1 false
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %is.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 64)
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_preserve_sign_daz_enabled_check_ieee() "denormal-fp-math"="ieee,ieee" {
+; CHECK-LABEL: @is_preserve_sign_daz_enabled_check_ieee(
+; CHECK-NEXT:    ret i1 false
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.neg.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 32)
+  ret i1 %is.neg.zero
+}
+
+define i1 @is_positive_zero_daz_enabled_check_ieee() "denormal-fp-math"="ieee,ieee" {
+; CHECK-LABEL: @is_positive_zero_daz_enabled_check_ieee(
+; CHECK-NEXT:    ret i1 false
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 64)
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_any_daz_enabled_check_ieee() "denormal-fp-math"="ieee,ieee" {
+; CHECK-LABEL: @is_any_daz_enabled_check_ieee(
+; CHECK-NEXT:    ret i1 false
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.any.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 96)
+  ret i1 %is.any.zero
+}
+
+define i1 @is_not_daz_enabled_check_ieee() "denormal-fp-math"="ieee,ieee" {
+; CHECK-LABEL: @is_not_daz_enabled_check_ieee(
+; CHECK-NEXT:    ret i1 true
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %is.not.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 959)
+  ret i1 %is.not.pos.zero
+}
+
+define i1 @is_poszero_daz_enabled_check_preserve_sign() "denormal-fp-math"="ieee,preserve-sign" {
+; CHECK-LABEL: @is_poszero_daz_enabled_check_preserve_sign(
+; CHECK-NEXT:    ret i1 true
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %is.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 64)
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_preserve_sign_daz_enabled_check_preserve_sign() "denormal-fp-math"="ieee,preserve-sign" {
+; CHECK-LABEL: @is_preserve_sign_daz_enabled_check_preserve_sign(
+; CHECK-NEXT:    ret i1 true
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.neg.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 32)
+  ret i1 %is.neg.zero
+}
+
+define i1 @is_positive_zero_daz_enabled_check_preserve_sign() "denormal-fp-math"="ieee,preserve-sign" {
+; CHECK-LABEL: @is_positive_zero_daz_enabled_check_preserve_sign(
+; CHECK-NEXT:    ret i1 false
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 64)
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_any_daz_enabled_check_preserve_sign() "denormal-fp-math"="ieee,preserve-sign" {
+; CHECK-LABEL: @is_any_daz_enabled_check_preserve_sign(
+; CHECK-NEXT:    ret i1 true
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.any.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 96)
+  ret i1 %is.any.zero
+}
+
+define i1 @is_not_daz_enabled_check_preserve_sign() "denormal-fp-math"="ieee,preserve-sign" {
+; CHECK-LABEL: @is_not_daz_enabled_check_preserve_sign(
+; CHECK-NEXT:    ret i1 false
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %is.not.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 959)
+  ret i1 %is.not.pos.zero
+}
+
+define i1 @is_poszero_daz_enabled_check_positive_zero() "denormal-fp-math"="ieee,positive-zero" {
+; CHECK-LABEL: @is_poszero_daz_enabled_check_positive_zero(
+; CHECK-NEXT:    ret i1 true
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %is.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 64)
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_preserve_sign_daz_enabled_check_positive_zero() "denormal-fp-math"="ieee,positive-zero" {
+; CHECK-LABEL: @is_preserve_sign_daz_enabled_check_positive_zero(
+; CHECK-NEXT:    ret i1 false
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.neg.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 32)
+  ret i1 %is.neg.zero
+}
+
+define i1 @is_positive_zero_daz_enabled_check_positive_zero() "denormal-fp-math"="ieee,positive-zero" {
+; CHECK-LABEL: @is_positive_zero_daz_enabled_check_positive_zero(
+; CHECK-NEXT:    ret i1 true
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 64)
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_any_daz_enabled_check_positive_zero() "denormal-fp-math"="ieee,positive-zero" {
+; CHECK-LABEL: @is_any_daz_enabled_check_positive_zero(
+; CHECK-NEXT:    ret i1 true
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 -2147483647 to float))
+  %is.any.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 96)
+  ret i1 %is.any.zero
+}
+
+define i1 @is_not_daz_enabled_check_positive_zero() "denormal-fp-math"="ieee,positive-zero" {
+; CHECK-LABEL: @is_not_daz_enabled_check_positive_zero(
+; CHECK-NEXT:    ret i1 false
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %is.not.pos.zero = call i1 @llvm.is.fpclass.f32(float %canonical, i32 959)
+  ret i1 %is.not.pos.zero
+}
+
+define i1 @is_poszero_daz_enabled_check_dynamic_bitcast() "denormal-fp-math"="ieee,dynamic" {
+; CHECK-LABEL: @is_poszero_daz_enabled_check_dynamic_bitcast(
+; CHECK-NEXT:    [[CANONICAL:%.*]] = call float @llvm.canonicalize.f32(float 0x36A0000000000000)
+; CHECK-NEXT:    [[BITCAST:%.*]] = bitcast float [[CANONICAL]] to i32
+; CHECK-NEXT:    [[IS_POS_ZERO:%.*]] = icmp eq i32 [[BITCAST]], 0
+; CHECK-NEXT:    ret i1 [[IS_POS_ZERO]]
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %bitcast = bitcast float %canonical to i32
+  %is.pos.zero = icmp eq i32 %bitcast, 0
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_poszero_daz_enabled_check_preserve_sign_bitcast() "denormal-fp-math"="ieee,preserve-sign" {
+; CHECK-LABEL: @is_poszero_daz_enabled_check_preserve_sign_bitcast(
+; CHECK-NEXT:    ret i1 true
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %bitcast = bitcast float %canonical to i32
+  %is.pos.zero = icmp eq i32 %bitcast, 0
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_poszero_daz_enabled_check_positive_zero_bitcast() "denormal-fp-math"="ieee,positive-zero" {
+; CHECK-LABEL: @is_poszero_daz_enabled_check_positive_zero_bitcast(
+; CHECK-NEXT:    ret i1 true
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %bitcast = bitcast float %canonical to i32
+  %is.pos.zero = icmp eq i32 %bitcast, 0
+  ret i1 %is.pos.zero
+}
+
+define i1 @is_poszero_daz_enabled_check_ieee_bitcast() "denormal-fp-math"="ieee,ieee" {
+; CHECK-LABEL: @is_poszero_daz_enabled_check_ieee_bitcast(
+; CHECK-NEXT:    ret i1 false
+;
+  %canonical = call float @llvm.canonicalize.f32(float bitcast (i32 1 to float))
+  %bitcast = bitcast float %canonical to i32
+  %is.pos.zero = icmp eq i32 %bitcast, 0
+  ret i1 %is.pos.zero
+}
+
 declare bfloat @llvm.canonicalize.bf16(bfloat)
 declare half @llvm.canonicalize.f16(half)
 declare float @llvm.canonicalize.f32(float)
 declare <2 x float> @llvm.canonicalize.v2f32(<2 x float>)
 declare double @llvm.canonicalize.f64(double)
 declare fp128 @llvm.canonicalize.fp128(fp128)
 declare x86_fp80 @llvm.canonicalize.f80(x86_fp80)
 declare ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128)
+declare i1 @llvm.is.fpclass.f32(float, i32 immarg)