Enable more constant foldings for switch ops using assertions

[EgorBo]

Closes #113992

This PR creates global assertions for switch targets.

An example from System.Text.Json:

public static ulong GetKey(ReadOnlySpan<byte> name)
{
    int length = name.Length;
    ulong key = (ulong)(byte)length << 56;

    switch (length)
    {
        case 0: goto ComputedKey;
        case 1: goto OddLength;
        case 2: key |= MemoryMarshal.Read<ushort>(name); goto ComputedKey;
        case 3: key |= MemoryMarshal.Read<ushort>(name); goto OddLength;
        case 4: key |= MemoryMarshal.Read<uint>(name); goto ComputedKey;
        case 5: key |= MemoryMarshal.Read<uint>(name); goto OddLength;
        case 6:
            key |= MemoryMarshal.Read<uint>(name) |
                   (ulong)MemoryMarshal.Read<ushort>(name.Slice(4, 2)) << 32; goto ComputedKey;
        case 7:
            key |= MemoryMarshal.Read<uint>(name) |
                   (ulong)MemoryMarshal.Read<ushort>(name.Slice(4, 2)) << 32; goto OddLength;
        default: key |= MemoryMarshal.Read<ulong>(name) & 0x00ffffffffffffffL; goto ComputedKey;
    }

    OddLength:
    int offset = length - 1;
    key |= (ulong)name[offset] << (offset * 8);

    ComputedKey:
    return key;
}

Codegen diff (Main vs PR): https://www.diffchecker.com/cxZY6tn3/ (still not perfect, though).

Another use-case is switch over string literals. Roslyn emits a trie-like algorithm for them where we do switch over string's length and end up comparing length inside all cases:

int Trie(string x) =>
    x switch
    {
        "1" => 1,
        "11" => 11,
        "111" => 111,
        "1111" => 1111,
        "11111" => 11111,
        "111111" => 111111,
        "1111111" => 1111111,
        "11111111" => 11111111,
        _ => 0
    };

Codegen diff (Main vs PR): https://www.diffchecker.com/CeHgRf8I/

[EgorBo]

@EgorBot -amd

using BenchmarkDotNet.Attributes;

public class Bench
{
    static string[] _strings = ["1", "10", "100", "1000", "10000", "100000", "1000000"];

    [Benchmark]
    public int Sum()
    {
        int sum = 0;
        foreach (string str in _strings)
        {
            sum += str switch
            {
                "1" => 1,
                "10" => 10,
                "100" => 100,
                "1000" => 1000,
                "10000" => 10000,
                "100000" => 100000,
                "1000000" => 1000000,
                _ => -1
            };
        }
        return sum;
    }
}

[Copilot]

Copilot wasn't able to review any files in this pull request.

Files not reviewed (2)

• src/coreclr/jit/assertionprop.cpp: Language not supported
• src/coreclr/jit/compiler.h: Language not supported

[EgorBo]

PTAL @AndyAyersMS @dotnet/jit-contrib Diffs

I decided to implement the assertion using a NOP node in all branches as the simplest impl, but as a follow up, I want to remove this "single assertion per tree" for Global Prop and write directly into block->bbAssertionGen (or bbAssertionIn).

My first impl was writing into bbAssertionIn/bbAssertionGen but it generated less diffs, presumably because we already ran optImpliedAssertions at that point.

[AndyAyersMS]

Looks good overall. Left you a few small things to consider.

[AndyAyersMS]

You should assert there are no PHI nodes in this block (there shouldn't be any since the block has a single pred edge).

[EgorBo]

Added an assert

[AndyAyersMS]

There are unlikely to be many switches so maybe keep track of them in the initial walk?

[EgorBo]

Done

[AndyAyersMS]

Do we need to bail if not same EH region? If the switch arm is a try entry still seems fine to add the assertion.

[EgorBo]

hm.. I think you're right, relaxed

[EgorBo]

/ba-g "azurelinux.3 timeouts"