Vector128Util.cs

Go to the documentation of this file.

#if NETCOREAPP3_0_OR_GREATER
 
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
 
namespace IKVM.Runtime.Util.Com.Sun.Crypto.Provider
{
 
    static class Vector128Util
    {
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void CopyTo<T>(this Vector128<T> vector, Span<T> destination) where T : struct
        {
#if NET8_0_OR_GREATER
            Vector128.CopyTo(vector, destination);
#else
            if (destination.Length < Vector128<T>.Count)
                throw new ArgumentException(null, nameof(destination));
 
            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
#endif
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector128<T> Create<T>(ReadOnlySpan<T> values) where T : struct
        {
#if NET8_0_OR_GREATER
            return Vector128.Create(values);
#else
            if (values.Length < Vector128<T>.Count)
                throw new ArgumentOutOfRangeException(nameof(values));
 
            return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
#endif
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static (Vector128<T> V1, Vector128<T> V2) Load2xUnsafe<T>(ref readonly T source) where T : struct
        {
            return (
                LoadUnsafe(in source, 0 * (nuint)Vector128<T>.Count),
                LoadUnsafe(in source, 1 * (nuint)Vector128<T>.Count)
            );
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static (Vector128<T> V1, Vector128<T> V2, Vector128<T> V3) Load3xUnsafe<T>(ref readonly T source) where T : struct
        {
            return (
                LoadUnsafe(in source, 0 * (nuint)Vector128<T>.Count),
                LoadUnsafe(in source, 1 * (nuint)Vector128<T>.Count),
                LoadUnsafe(in source, 2 * (nuint)Vector128<T>.Count)
            );
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static (Vector128<T> V1, Vector128<T> V2, Vector128<T> V3, Vector128<T> V4) Load4xUnsafe<T>(ref readonly T source) where T : struct
        {
            return (
                LoadUnsafe(in source, 0 * (nuint)Vector128<T>.Count),
                LoadUnsafe(in source, 1 * (nuint)Vector128<T>.Count),
                LoadUnsafe(in source, 2 * (nuint)Vector128<T>.Count),
                LoadUnsafe(in source, 3 * (nuint)Vector128<T>.Count)
            );
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector128<T> LoadUnsafe<T>(ref readonly T source) where T : struct
        {
#if NET8_0_OR_GREATER
            return Vector128.LoadUnsafe(in source);
#else
            // Use with caution.
            // Supports blittable primitives only.
            ref byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
            return Unsafe.ReadUnaligned<Vector128<T>>(ref address);
#endif
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector128<T> LoadUnsafe<T>(ref readonly T source, nuint elementOffset) where T : struct
        {
#if NET8_0_OR_GREATER
            return Vector128.LoadUnsafe(in source, elementOffset);
#else
            // Use with caution.
            // Supports blittable primitives only.
            ref byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
            return Unsafe.ReadUnaligned<Vector128<T>>(ref address);
#endif
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void StoreUnsafe<T>(this Vector128<T> source, ref T destination) where T : struct
        {
#if NET8_0_OR_GREATER
            Vector128.StoreUnsafe(source, ref destination);
#else
            // Use with caution.
            // Supports blittable primitives only.
            ref byte address = ref Unsafe.As<T, byte>(ref destination);
            Unsafe.WriteUnaligned(ref address, source);
#endif
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void StoreUnsafe<T>(this Vector128<T> source, ref T destination, nuint elementOffset) where T : struct
        {
#if NET8_0_OR_GREATER
            Vector128.StoreUnsafe(source, ref destination, elementOffset);
#else
            // Use with caution.
            // Supports blittable primitives only.
            destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
#endif
        }
    }
}
 
#endif