SIMD problems when mixing llvm and non-llvm code

[vargaz]

Description

Currently on mono, SIMD is only supported when using LLVM compiled code. This can lead to various problems when mixing llvm and non-llvm compiled code. This mixing can happen for various reasons:

• profiled AOT
• LLVM doesn't support some IL constructs like filter clauses

1. Different calling conventions
   LLVM code passes SIMD types in SIMD registers, while JITted code passes them on the stack.
   Testcase:

using System;
using System.Numerics;

public class Tests
{
    public static void Main () {
        foo (new Vector<int> (1));
    }

    static void foo (Vector<int> v) {
        try {
            Console.WriteLine (v);
        } catch (Exception ex) when (ex is OverflowException) {
            }
    }
}

2. The IsSupported methods return different values in LLVM and non-LLVM methods, leading to subtle logic problems:

using System;
using System.Numerics;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;

public class Tests
{
    public static void Main () {
        if (AdvSimd.Arm64.IsSupported)
            foo (new Vector128<double> ());
    }

    static void foo (Vector128<double> v) {
        try {
        } catch (Exception ex) when (ex is OverflowException) {
            }
        AdvSimd.Arm64.Abs (v);
    }
}

This will fail when AOT-ed using --aot=llvm

Reproduction Steps

.

Expected behavior

.

Actual behavior

.

Regression?

No response

Known Workarounds

No response

Configuration

No response

Other information

No response

[dotnet-issue-labeler]

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.

[vargaz]

@fanyang-mono

[lambdageek]

This is another instance of the same problem #73003

Basically as long as we have a fallback execution engine (JIT or interpreter) that doesn't support some intrinsic (or returns IsSupported == false) we can't really support that intrinsic in an AOT mode (or return IsSupported == true)

[SamMonoRT]

@lambdageek @fanyang-mono -- with #74357 merged(backported), I think we can move this to 8.0.0 ?

[fanyang-mono]

I think so. If @vargaz has some idea of a quick fix for this, he could move it back later.

[lambdageek]

we need to also do something with calling conventions

[MichalStrehovsky]

MichalStrehovsky closed this as completed in bflattened/runtime@b9e2214

@vargaz Sorry about that - created a dummy default branch in that repo so that this never happens again.

[fanyang-mono]

Moving this issue to .NET8, since we didn't had the bandwidth to handle it during .NET7.

[SamMonoRT]

@fanyang-mono with recent intrinsic implementations and reverting for removing fallback paths, can this be closed?

[matouskozak]

I tested both cases with miniJIT and normal AOT with LLVM and both are working. However, I encountered failures during running fullAOT with LLVM versions of both cases. I'll investigate further what is causing these failures.

[matouskozak]

I ran additional tests on osx-arm64 and these are the results:

1. Different calling conventions:
   Tested with miniJIT and AOT/fullAOT (llvm) and both seem to be passing the Vector type using stack.

2. The IsSupported methods return different values in LLVM and non-LLVM methods, leading to subtle logic problems:
   Tested with AOT/fullAOT (llvm) and both are working (not failing). My previously reported failures using fullAOT (llvm) were due to misconfigured build script.

[fanyang-mono]

Based on @matouskozak's testing, the SIMD behavior between various codegen engines are aligned now. Closing this issue.