Marshalling Vector128<float> as return type in native interop call in .NET 7.0

Interop.cs

using System.Runtime.InteropServices;

internal static partial class Interop
{
    [LibraryImport("kernel32.dll")]
    public static partial void GetSystemInfo(out SystemInfo Info);

    [LibraryImport("kernel32.dll")]
    public static partial IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, AllocationType flAllocationType, MemoryProtection flProtect);

    [LibraryImport("kernel32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static partial bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, UIntPtr dwSize, MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);

    [LibraryImport("kernel32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static partial bool VirtualFreeEx(IntPtr hProcess, IntPtr lpAddress, int dwSize, FreeType dwFreeType);

    public struct SystemInfo
    {
        public ushort wProcessorArchitecture;
        public ushort wReserved;
        public uint dwPageSize;
        public IntPtr lpMinimumApplicationAddress;
        public IntPtr lpMaximumApplicationAddress;
        public IntPtr dwActiveProcessorMask;
        public uint dwNumberOfProcessors;
        public uint dwProcessorType;
        public uint dwAllocationGranularity;
        public ushort wProcessorLevel;
        public ushort wProcessorRevision;
    }

    [Flags]
    public enum AllocationType : uint
    {
        Commit = 0x1000,
        Reserve = 0x2000,
        Decommit = 0x4000,
        Release = 0x8000,
        Reset = 0x80000,
        Physical = 0x400000,
        TopDown = 0x100000,
        WriteWatch = 0x200000,
        LargePages = 0x20000000
    }

    [Flags]
    public enum MemoryProtection : uint
    {
        Execute = 0x10,
        ExecuteRead = 0x20,
        ExecuteReadWrite = 0x40,
        ExecuteWriteCopy = 0x80,
        NoAccess = 0x01,
        ReadOnly = 0x02,
        ReadWrite = 0x04,
        WriteCopy = 0x08,
        GuardModifierflag = 0x100,
        NoCacheModifierflag = 0x200,
        WriteCombineModifierflag = 0x400
    }

    [Flags]
    public enum FreeType : uint
    {
        Decommit = 0x4000,
        Release = 0x8000,
    }
}

NativeLibrary.h

#include <xmmintrin.h>

__declspec(dllexport) __m128 MyNativeFunction(__m128);

Usage.cs

using System.Runtime.InteropServices;
using System.Runtime.InteropServices.Marshalling;
using System.Runtime.Intrinsics;

public static class MyClass
{
    [LibraryImport("MyNativeLibrary")]
    [return: MarshalUsing(typeof(Vector128ReturnMarshaller<>))]
    public static partial Vector128<float> MyNativeFunction(Vector128<float>* input);
}

Vector128ReturnMarshaller_1.cs

using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.Marshalling;
using System.Runtime.Intrinsics;

[CustomMarshaller(typeof(Vector128<>), MarshalMode.Default, typeof(Vector128ReturnMarshaller<>.Marshaller))]
public static class Vector128ReturnMarshaller<T>
    where T : struct
{
    public readonly unsafe struct Marshaller
    {
        private readonly Vector128<T> _result;

        private readonly nint _processHandle;

        private readonly nint _buffer;
        private readonly delegate* unmanaged<void> _functionPointer;

        public Marshaller()
        {
            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || RuntimeInformation.ProcessArchitecture != Architecture.X64)
            {
                // TODO: Check what happens with Vector128 marshalling on other platforms and architectures.
                throw new NotSupportedException("This code only works on Windows x64");
            }

            Span<byte> code = stackalloc byte[]
            {
                // movabs rax, 0x000000000000000
                0x48, 0xB8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

                // movups XMMWORD PTR [rax], xmm0
                0x0F, 0x11, 0x00,

                // ret
                0xC3,
            };

            // Patch the movabs instruction source operand with the address of our _result field.
            var codePtr = MemoryMarshal.Cast<byte, nint>(code[2..]);
            codePtr[0] = (nint)Unsafe.AsPointer(ref _result);

            Interop.GetSystemInfo(out var systemInfo);
            var pageSize = systemInfo.dwPageSize;

            _processHandle = Process.GetCurrentProcess().Handle;
            _buffer = Interop.VirtualAllocEx(_processHandle, 0, (nint)pageSize, Interop.AllocationType.Commit, Interop.MemoryProtection.ReadWrite);

            var bufferSpan = new Span<byte>((void*)_buffer, (int)pageSize);
            code.CopyTo(bufferSpan);

            Interop.VirtualProtectEx(_processHandle, _buffer, (nuint)code.Length, Interop.MemoryProtection.ExecuteRead, out var _);

            _functionPointer = (delegate* unmanaged<void>)(_buffer);
        }

        public void FromUnmanaged(float value) { }

        public Vector128<T> ToManaged()
        {
            // Result vector is in XMM0 register. Copy it into our _result field.
            _functionPointer();

            return _result;
        }

        public void Free()
        {
            Interop.VirtualFreeEx(_processHandle, _buffer, 0, Interop.FreeType.Release);
        }
    }
}