JIT: Physical promotion readback mechanism does not take implicit control flow into account

[jakobbotsch]

Physical promotion currently relies on being able to insert pending read backs before control is transferred to any successor block. This happens at the end of the block, but doing it this way does not take implicit control flow into account. For example:

using System;
using System.Runtime.CompilerServices;

public class Program
{
    public static int Main()
    {
        int result = Test();
        if (result == 100)
        {
            Console.WriteLine("PASS");
        }
        else
        {
            Console.WriteLine("FAIL: Returned {0}", result);
        }

        return result;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int Test()
    {
        Foo f = new();
        try
        {
            f.X = 15;
            f.Y = 20;
            f.X += f.Y;
            f.Y *= f.X;

            // f will be physically promoted and will require a read back after this call.
            // However, there is implicit control flow happening that the read back should happen before.
            f = Call(f);
            ThrowException();
            return -1;
        }
        catch (Exception ex)
        {
            return f.X + f.Y;
        }
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    private static Foo Call(Foo f)
    {
        return new Foo { X = 75, Y = 25 };
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    private static void ThrowException()
    {
        throw new Exception();
    }

    private struct Foo
    {
        public short X, Y;
    }
}

To fix we can likely insert any pending read backs before any GTF_EXCEPT marked tree when in a try region.

[ghost]

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

Issue Details

---

Physical promotion currently relies on being able to insert pending read backs before control flow is transferred to any successor block. This happens at the end of the block, but doing it this way does not take implicit control flow into account. For example:

using System;
using System.Runtime.CompilerServices;

public class Program
{
    public static int Main()
    {
        int result = Test();
        if (result == 100)
        {
            Console.WriteLine("PASS");
        }
        else
        {
            Console.WriteLine("FAIL: Returned {0}", result);
        }

        return result;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int Test()
    {
        Foo f = new();
        try
        {
            f.X = 15;
            f.Y = 20;
            f.X += f.Y;
            f.Y *= f.X;

            // f will be physically promoted and will require a read back after this call.
            // However, there is implicit control flow happening that the read back should happen before.
            f = Call(f);
            ThrowException();
            return -1;
        }
        catch (Exception ex)
        {
            return f.X + f.Y;
        }
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    private static Foo Call(Foo f)
    {
        return new Foo { X = 75, Y = 25 };
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    private static void ThrowException()
    {
        throw new Exception();
    }

    private struct Foo
    {
        public short X, Y;
    }
}

To fix we can likely insert any pending read backs before any GTF_EXCEPT marked tree when in a try region.

Author:	jakobbotsch
Assignees:	-
Labels:	area-CodeGen-coreclr, untriaged
Milestone:	-