JIT difference in debug/release output

[dhartglassMSFT]

SBC reduced from Antigen-generated code

Prints int_70=-1 on Debug configurations, prints int_70=-4194304 on Release.

The Method16 call is needed for the reproduction, if that's commented out then Dbg/Rel agree

using System.Numerics;
public class TestClass
{
    public struct S2 { }
    Vector<float> v_float_117 = Vector<float>.AllBitsSet;
    public void Method16(out S2 p_s2_567, Vector<float> p_v_float_568)
    {
            p_s2_567 = default;
    }
    public void Method0()
    {
            v_float_117 += Vector.Create(float.NaN);
            Method16(out _, Vector.Create(float.NaN));
            int int_70 = Vector.GetElement(Vector.AsVectorInt32(v_float_117), 0);
            Log("int_70", int_70);
    }
    public static int Main(string[] args) { new TestClass().Method0(); return 0; }
    public static void Log(string n, object v) { System.Console.WriteLine($"{n}={v}"); }
}

/*
Environment:
set DOTNET_TieredCompilation=0
*/

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[tannergooding]

The Method16 call is needed for the reproduction, if that's commented out then Dbg/Rel agre

I don't see this, I can get a repro with just:

using System;
using System.Numerics;

public class TestClass
{
    static Vector<float> v_float_117 = Vector<float>.AllBitsSet;
    public static void Main(string[] args)
    {
        v_float_117 += Vector.Create(float.NaN);
        int int_70 = Vector.GetElement(Vector.AsVectorInt32(v_float_117), 0);
        Console.WriteLine($"int_70={int_70:X8}");
    }
}

---

This is notably however expected and "by design". This involves NaN and so the exact bitwise value isn't guaranteed, just that we will return "some NaN". In this case it's because in Release we see we're adding with NaN and so constant fold it to the NaN we see rather than the NaN we don't see.

In other words, the underlying calculation is doing x + y where x = NaN1 and y = NaN2. xarch (and most platforms) choose to propagate the first NaN in this scenario and so return x (NaN1), which happens to be AllBitsSet. In release mode we end up doing constant folding and such and so see x + NaN and while we don't know the value of x, we know that x + NaN always produces NaN and choose to propagate this instead (which happens to be the canonical NaN).

If you inverse the expression so you have v_float_117 = Vector.Create(float.NaN) and then v_float_117 += Vector<float>.AllBitsSet you'll see that the debug vs release output swaps correspondingly.

---

Antigen needs to ensure it understands that operations involving NaN may not produce bitwise identical results between modes.