Code a little larger when cast omitted that could be inferred

[danmoseley]

In this code,

using System;
public class C {
    public bool M1(float f) {
        return (Math.Abs(f) >= 0.5);
    }
    
    public bool M2(float f) {
        return (Math.Abs(f) >= (float)0.5);
    }  
}

ideally the code generated would be the same, as so far as I know the behavior is the same, but the code without the explicit cast is a little longer.

C.M1(Single)
    L0000: vzeroupper
    L0003: vmovss xmm1, [esp+4]
    L0009: vmovss xmm0, [C.M1(Single)]
    L0011: vandps xmm1, xmm1, xmm0
    L0015: vcvtss2sd xmm0, xmm0, xmm1
    L0019: vucomisd xmm0, [C.M1(Single)]
    L0021: setae al
    L0024: movzx eax, al
    L0027: ret 4

C.M2(Single)
    L0000: vzeroupper
    L0003: vmovss xmm1, [esp+4]
    L0009: vmovss xmm0, [C.M2(Single)]
    L0011: vandps xmm1, xmm1, xmm0
    L0015: vucomiss xmm1, [C.M2(Single)]
    L001d: setae al
    L0020: movzx eax, al
    L0023: ret 4

https://sharplab.io/#v2:EYLgtghgzgLgpgJwDQxNMAfAAgJgIwCwAUFgMwAEu5AwuQN7HlOUXAD2bANuQLJ4AUAM05sIMcoICU9RszlYA7OX48xACwB0AQWBQh0gHwBecgAYNAVkkBuWUwC+d8k7Ll2XXjiEixE6QyI5eSUVdW1dfXJjZWFRGElzK1tA5nsmYnsgA===

was mentioned in #41140 (comment)

category:cq
theme:floating-point
skill-level:intermediate
cost:medium

[Dotnet-GitSync-Bot]

I couldn't figure out the best area label to add to this issue. If you have write-permissions please help me learn by adding exactly one area label.

[am11]

Library-free repro:

public class C
{
    public bool M1(float f) => f >= 0.5;    
    public bool M2(float f) => f >= 0.5f;
}

Diff:

--- M1()
+++ M2()

vzeroupper
- vcvtss2sd xmm0, xmm0, [esp+4]
- vucomisd xmm0, [C.M1(Single)]
+ vmovss xmm0, [esp+4]
+ vucomiss xmm0, [C.M2(Single)]
setae al
movzx eax, al
ret 4

cc @EgorBo

[EgorBo]

NOTE:

bool M1(float f) { return f >= 1.5; } // safe to convert to float
bool M2(float f) { return f >= 1.6; } // unsafe

Related LLVM optimization: https://github.com/llvm/llvm-project/blob/de044f756286edebf86044d5172016d87f49fda0/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp#L6285-L6296 it'd be nice to borrow APFloat implementation from LLVM with all those useful APIs (isNormal, isFinite, getSmallestNormalized, etc) 🙂

[EgorBo]

@tannergooding is it safe to rely on platform float/double in JIT for this optimization, e.g.:
(pseudocode)

double cns = ...;
if (IsNormalized(cns) && IsFinite(cns) && isNotNaN(cns))
{
    bool lossy = DoubleToInt64Bits((double)(float)cns) != DoubleToInt64Bits(cns);
    if (!lossy)
    {
        // do optimization
    }
}

[tannergooding]

@EgorBo, if you know it is not NaN then just (double)(float)cns != cns should be sufficient, assuming the platform is following normal IEEE floating-point rules and not performing any fast-math optimizations.

That being said, IsNormalized, IsFinite, and IsNaN all have to do raw bit checks and so its probably cheaper and more correct to just get the raw bits and validate the unbiased exponent and significands match (as it won't fail due to accidental platform bugs).

[KalleOlaviNiemitalo]

bool M1(float f) { return f >= 1.5; } // safe to convert to float
bool M2(float f) { return f >= 1.6; } // unsafe

Can you use directed rounding for this? Assuming float f:

• f >= 1.6 ⇔ f > 1.6 ⇔ f > 0.15999999642372131f ⇔ f >= 0.16000001132488251f
• f <= 1.6 ⇔ f < 1.6 ⇔ f <= 0.15999999642372131f ⇔ f < 0.16000001132488251f
• f == 1.6 ⇔ false
• f != 1.6 ⇔ true