ValueTracking: uitofp/sitofp cannot return denormal results

[foad]

Thanks.

I suppose you could imagine a future floating point format where the range of exponents did not include 0, and integer values could be subnormal, but that would be pretty bizarre.

[arsenm]

83adfc91e811815955a34a5ce72eb4a0ea2ff0e3

llvm/lib/Analysis/ValueTracking.cpp

if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Op)) {
       }
       case Intrinsic::experimental_constrained_sitofp:
       case Intrinsic::experimental_constrained_uitofp:
         // Cannot produce nan
         Known.knownNot(fcNan);
 
         // sitofp and uitofp turn into +0.0 for zero.
         Known.knownNot(fcNegZero);
+
+        // Integers cannot be subnormal
+        Known.knownNot(fcSubnormal);
+
         if (IID == Intrinsic::experimental_constrained_uitofp)
           Known.signBitIsZero();
 
         // TODO: Copy inf handling from instructions
         break;
       default:
         break;
       }
case Instruction::FPTrunc: {
     // Infinity needs a range check.
     break;
   }
   case Instruction::SIToFP:
   case Instruction::UIToFP: {
     // Cannot produce nan
     Known.knownNot(fcNan);
 
+    // Integers cannot be subnormal
+    Known.knownNot(fcSubnormal);
+
     // sitofp and uitofp turn into +0.0 for zero.
     Known.knownNot(fcNegZero);
     if (Op->getOpcode() == Instruction::UIToFP)
       Known.signBitIsZero();
 
     if (InterestedClasses & fcInf) {
       // Get width of largest magnitude integer (remove a bit if signed).
       // This still works for a signed minimum value because the largest FP

llvm/test/Transforms/Attributor/nofpclass.ll

;
   %alloca = alloca float
   store float %arg, ptr %alloca
   %ret = call float @returned_load(ptr %alloca)
   ret float %ret
 }
 
 define float @uitofp_i32_to_f32(i32 %arg) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define nofpclass(nan inf nzero nsub nnorm) float @uitofp_i32_to_f32
+; CHECK-LABEL: define nofpclass(nan inf nzero sub nnorm) float @uitofp_i32_to_f32
 ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[CVT:%.*]] = uitofp i32 [[ARG]] to float
 ; CHECK-NEXT:    ret float [[CVT]]
 ;
   %cvt = uitofp i32 %arg to float
   ret float %cvt
 }
 
 define float @sitofp_i32_to_f32(i32 %arg) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define nofpclass(nan inf nzero) float @sitofp_i32_to_f32
+; CHECK-LABEL: define nofpclass(nan inf nzero sub) float @sitofp_i32_to_f32
 ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[CVT:%.*]] = sitofp i32 [[ARG]] to float
 ; CHECK-NEXT:    ret float [[CVT]]
 ;
   %cvt = sitofp i32 %arg to float
   ret float %cvt
 }
 
 define <2 x float> @uitofp_v2i32_to_v2f32(<2 x i32> %arg) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define nofpclass(nan inf nzero nsub nnorm) <2 x float> @uitofp_v2i32_to_v2f32
+; CHECK-LABEL: define nofpclass(nan inf nzero sub nnorm) <2 x float> @uitofp_v2i32_to_v2f32
 ; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[CVT:%.*]] = uitofp <2 x i32> [[ARG]] to <2 x float>
 ; CHECK-NEXT:    ret <2 x float> [[CVT]]
 ;
   %cvt = uitofp <2 x i32> %arg to <2 x float>
   ret <2 x float> %cvt
 }
 
 define <2 x float> @sitofp_v2i32_to_v2i32(<2 x i32> %arg) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define nofpclass(nan inf nzero) <2 x float> @sitofp_v2i32_to_v2i32
+; CHECK-LABEL: define nofpclass(nan inf nzero sub) <2 x float> @sitofp_v2i32_to_v2i32
 ; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[CVT:%.*]] = sitofp <2 x i32> [[ARG]] to <2 x float>
 ; CHECK-NEXT:    ret <2 x float> [[CVT]]
 ;
   %cvt = sitofp <2 x i32> %arg to <2 x float>
   ret <2 x float> %cvt
 }
 
 define half @uitofp_i17_to_f16(i17 %arg) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) half @uitofp_i17_to_f16
+; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) half @uitofp_i17_to_f16
 ; CHECK-SAME: (i17 [[ARG:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[CVT:%.*]] = uitofp i17 [[ARG]] to half
 ; CHECK-NEXT:    ret half [[CVT]]
 ;
   %cvt = uitofp i17 %arg to half
   ret half %cvt
 }
 
 define half @sitofp_i17_to_f16(i17 %arg) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define nofpclass(nan nzero) half @sitofp_i17_to_f16
+; CHECK-LABEL: define nofpclass(nan nzero sub) half @sitofp_i17_to_f16
 ; CHECK-SAME: (i17 [[ARG:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[CVT:%.*]] = sitofp i17 [[ARG]] to half
 ; CHECK-NEXT:    ret half [[CVT]]
 ;
   %cvt = sitofp i17 %arg to half
   ret half %cvt
 }
 
 define <2 x half> @uitofp_v2i17_to_v2f16(<2 x i17> %arg) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) <2 x half> @uitofp_v2i17_to_v2f16
+; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) <2 x half> @uitofp_v2i17_to_v2f16
 ; CHECK-SAME: (<2 x i17> [[ARG:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[CVT:%.*]] = uitofp <2 x i17> [[ARG]] to <2 x half>
 ; CHECK-NEXT:    ret <2 x half> [[CVT]]
 ;
   %cvt = uitofp <2 x i17> %arg to <2 x half>
   ret <2 x half> %cvt
 }
 
 define <2 x half> @sitofp_v2i17_to_v2i17(<2 x i17> %arg) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define nofpclass(nan nzero) <2 x half> @sitofp_v2i17_to_v2i17
+; CHECK-LABEL: define nofpclass(nan nzero sub) <2 x half> @sitofp_v2i17_to_v2i17
 ; CHECK-SAME: (<2 x i17> [[ARG:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[CVT:%.*]] = sitofp <2 x i17> [[ARG]] to <2 x half>
 ; CHECK-NEXT:    ret <2 x half> [[CVT]]
 ;
   %cvt = sitofp <2 x i17> %arg to <2 x half>
   ret <2 x half> %cvt
 }
 

 ; CHECK-NEXT:    ret float [[SUB]]
 ;
   %sub = fsub float -0.0, %arg0
   ret float %sub
 }
 
 define float @constrained_sitofp(i32 %arg) strictfp {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite)
-; CHECK-LABEL: define nofpclass(nan nzero) float @constrained_sitofp
+; CHECK-LABEL: define nofpclass(nan nzero sub) float @constrained_sitofp
 ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR5:[0-9]+]] {
-; CHECK-NEXT:    [[VAL:%.*]] = call nofpclass(nan nzero) float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR7]]
+; CHECK-NEXT:    [[VAL:%.*]] = call nofpclass(nan nzero sub) float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR7]]
 ; CHECK-NEXT:    ret float [[VAL]]
 ;
   %val = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
   ret float %val
 }
 
 define float @constrained_uitofp(i32 %arg) strictfp {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite)
-; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @constrained_uitofp
+; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @constrained_uitofp
 ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR5]] {
-; CHECK-NEXT:    [[VAL:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR7]]
+; CHECK-NEXT:    [[VAL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR7]]
 ; CHECK-NEXT:    ret float [[VAL]]
 ;
   %val = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
   ret float %val
 }

llvm/unittests/Analysis/ValueTrackingTest.cpp

 
 TEST_F(ComputeKnownFPClassTest, UIToFP) {
   parseAssembly(
       "define float @test(i32 %arg0, i16 %arg1) {\n"
       "  %A = uitofp i32 %arg0 to float"
       "  %A2 = uitofp i16 %arg1 to half"
       "  ret float %A\n"
       "}\n");
-  expectKnownFPClass(fcPosFinite, false, A);
-  expectKnownFPClass(fcPositive, false, A2);
+  expectKnownFPClass(fcPosFinite & ~fcSubnormal, false, A);
+  expectKnownFPClass(fcPositive & ~fcSubnormal, false, A2);
 }
 
 TEST_F(ComputeKnownFPClassTest, SIToFP) {
   parseAssembly(
       "define float @test(i32 %arg0, i16 %arg1, i17 %arg2) {\n"
       "  %A = sitofp i32 %arg0 to float"
       "  %A2 = sitofp i16 %arg1 to half"
       "  %A3 = sitofp i17 %arg2 to half"
       "  ret float %A\n"
       "}\n");
-  expectKnownFPClass(fcFinite & ~fcNegZero, std::nullopt, A);
-  expectKnownFPClass(fcFinite & ~fcNegZero, std::nullopt, A2);
-  expectKnownFPClass(~(fcNan | fcNegZero), std::nullopt, A3);
+  expectKnownFPClass(fcFinite & ~fcNegZero & ~fcSubnormal, std::nullopt, A);
+  expectKnownFPClass(fcFinite & ~fcNegZero & ~fcSubnormal, std::nullopt, A2);
+  expectKnownFPClass(~(fcNan | fcNegZero | fcSubnormal), std::nullopt, A3);
 }
 
 TEST_F(ComputeKnownFPClassTest, FAdd) {
   parseAssembly(
       "define float @test(float nofpclass(nan inf) %nnan.ninf, float nofpclass(nan) %nnan, float nofpclass(qnan) %no.qnan, float %unknown) {\n"
       "  %A = fadd float %nnan, %nnan.ninf"
       "  %A2 = fadd float %nnan.ninf, %nnan"
       "  %A3 = fadd float %nnan.ninf, %unknown"