Refactoring the ARM Hardware Intrinsics based on the latest design decisions. (dotnet...

* Moving the Arm64 intrinsic files into the Arm folder.

* Refactoring the ARM Hardware Intrinsics based on the new design.

* Adding support for AdvSimd.Add

* Adding LoadVector64 and LoadVector128 APIs to Arm.AdvSimd

* Marking the LoadVector64 and LoadVector128 methods as unsafe

* Removing the ARM64 HWIntrinsic tests

* Renaming Arm.Base to Arm.ArmBase, as per the design

* Fixing Base.cs to ArmBase.cs in the shared projitems

* Fixing the doc comments for the AdvSimd.LoadVector methods

* Marking various IsSupported methods as new, now that they inherit from ArmBase

* Fixing a malformed doc comment that was missed

* Marking AdvSimd.Arm64 as [Intrinsic] and new

Commit migrated from https://github.com/dotnet/coreclr/commit/14b66ba36669ac002de415c4e8f19792e1c721e8

diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Base.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Base.cs
deleted file mode 100644 (file)
index 16f67cc..0000000
--- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Base.cs
+++ /dev/null
@@ -1,167 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.Intrinsics.Arm.Arm64;
-
-namespace Arm64intrisicsTest
-{
-    class Program
-    {
-        static void testUnaryOp<T>(String testCaseDescription, Func<T, int> func, int expected, T value)
-        {
-            bool failed = false;
-            try
-            {
-                int result = func(value);
-
-                if (result != expected)
-                {
-                    Console.WriteLine($"testUnaryOp<{typeof(T).Name}>{testCaseDescription}: Check Failed");
-                    Console.WriteLine($"    result = {result}, expected = {expected}");
-                    throw new Exception($"testUnaryOp<{typeof(T).Name}>{testCaseDescription}: Failed");
-                }
-            }
-            catch
-            {
-                Console.WriteLine($"testUnaryOp<{typeof(T).Name}>{testCaseDescription}: Unexpected exception");
-                throw;
-            }
-        }
-
-        static void testThrowsPlatformNotSupported<T>(String testCaseDescription, Func<T, int> func, T value)
-        {
-            bool notSupported = false;
-
-            try
-            {
-                func(value);
-            }
-            catch (PlatformNotSupportedException)
-            {
-                notSupported = true;
-            }
-            catch
-            {
-                Console.WriteLine($"testThrowsPlatformNotSupported: Unexpected exception");
-                throw;
-            }
-
-            if (notSupported == false)
-            {
-                throw new Exception($"testThrowsPlatformNotSupported<{typeof(T).Name} >{testCaseDescription}: Failed");
-            }
-        }
-
-        static int s_SignBit32 = 1 << 31;
-        static long s_SignBit64 = 1L << 63;
-
-        static int GenLeadingSignBitsI32(int num)
-        {
-            Debug.Assert(0 <= num && num < 32);
-            return s_SignBit32 >> num;
-        }
-
-        static long GenLeadingSignBitsI64(int num)
-        {
-            Debug.Assert(0 <= num && num < 64);
-            return s_SignBit64 >> num;
-        }
-
-        static uint GenLeadingZeroBitsU32(int num)
-        {
-            Debug.Assert(0 <= num && num <= 32);
-            return (num < 32) ? (~0U >> num) : 0;
-        }
-
-        static int GenLeadingZeroBitsI32(int num)
-        {
-            return (int)GenLeadingZeroBitsU32(num);
-        }
-
-        static ulong GenLeadingZeroBitsU64(int num)
-        {
-            Debug.Assert(0 <= num && num <= 64);
-            return (num < 64) ? (~0UL >> num) : 0;
-        }
-
-        static long GenLeadingZeroBitsI64(int num)
-        {
-            return (long)GenLeadingZeroBitsU64(num);
-        }
-
-        static void TestLeadingSignCount()
-        {
-            String name = "LeadingSignCount";
-
-            if (Base.IsSupported)
-            {
-                for (int num = 0; num < 32; num++)
-                {
-                     testUnaryOp<int>(name, (x) => Base.LeadingSignCount(x), num,  GenLeadingSignBitsI32(num));
-                }
-
-                for (int num = 0; num < 64; num++)
-                {
-                     testUnaryOp<long>(name, (x) => Base.LeadingSignCount(x), num,  GenLeadingSignBitsI64(num));
-                }
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<int >(name, (x) => Base.LeadingSignCount(x), 0);
-                testThrowsPlatformNotSupported<long>(name, (x) => Base.LeadingSignCount(x), 0);
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestLeadingZeroCount()
-        {
-            String name = "LeadingZeroCount";
-
-            if (Base.IsSupported)
-            {
-                for (int num = 0; num <= 32; num++)
-                {
-                     testUnaryOp<int >(name, (x) => Base.LeadingZeroCount(x), num,  GenLeadingZeroBitsI32(num));
-                     testUnaryOp<uint>(name, (x) => Base.LeadingZeroCount(x), num,  GenLeadingZeroBitsU32(num));
-                }
-
-                for (int num = 0; num <= 64; num++)
-                {
-                     testUnaryOp<long >(name, (x) => Base.LeadingZeroCount(x), num,  GenLeadingZeroBitsI64(num));
-                     testUnaryOp<ulong>(name, (x) => Base.LeadingZeroCount(x), num,  GenLeadingZeroBitsU64(num));
-                }
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<int  >(name, (x) => Base.LeadingZeroCount(x), 0);
-                testThrowsPlatformNotSupported<uint >(name, (x) => Base.LeadingZeroCount(x), 0);
-                testThrowsPlatformNotSupported<long >(name, (x) => Base.LeadingZeroCount(x), 0);
-                testThrowsPlatformNotSupported<ulong>(name, (x) => Base.LeadingZeroCount(x), 0);
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void ExecuteAllTests()
-        {
-            TestLeadingSignCount();
-            TestLeadingZeroCount();
-        }
-
-        static int Main(string[] args)
-        {
-            Console.WriteLine($"System.Runtime.Intrinsics.Arm.Arm64.Base.IsSupported = {Base.IsSupported}");
-
-            // Reflection call
-            var issupported = "get_IsSupported";
-            bool reflectedIsSupported = Convert.ToBoolean(typeof(Base).GetMethod(issupported).Invoke(null, null));
-
-            Debug.Assert(reflectedIsSupported == Base.IsSupported, "Reflection result does not match");
-
-            ExecuteAllTests();
-
-            return 100;
-        }
-    }
-}

diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Base.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Base.csproj
deleted file mode 100644 (file)
index f3ae7d0..0000000
--- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Base.csproj
+++ /dev/null
@@ -1,13 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-  <PropertyGroup>
-    <DebugType>None</DebugType>
-    <Optimize>True</Optimize>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="Base.cs" />
-  </ItemGroup>
-</Project>

diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Crypto.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Crypto.cs
deleted file mode 100644 (file)
index fded506..0000000
--- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Crypto.cs
+++ /dev/null
@@ -1,325 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm.Arm64;
-
-namespace Arm64intrisicsTest
-{
-
-    class Program
-    {
-
-        struct DataSet<TBaseType, TVectorType>
-            where TBaseType : struct
-            where TVectorType : new()
-        {
-            private static TVectorType _vectorX;
-            private static TVectorType _vectorY;
-            private static TVectorType _vectorZ;
-
-            public static TVectorType vectorX { get { return _vectorX; }}
-            public static TVectorType vectorY { get { return _vectorY; }}
-            public static TVectorType vectorZ { get { return _vectorZ; }}
-
-            public static TBaseType[] arrayX { get; private set; }
-            public static TBaseType[] arrayY { get; private set; }
-            public static TBaseType[] arrayZ { get; private set; }
-
-            public static unsafe void setData(TBaseType[] x, TBaseType[] y)
-            {
-                arrayX = x;
-                arrayY = y;
-
-                GCHandle handleSrc = GCHandle.Alloc(x, GCHandleType.Pinned);
-
-                try
-                {
-                    var ptrSrc = (byte*) handleSrc.AddrOfPinnedObject().ToPointer();
-
-                    _vectorX = Unsafe.Read<TVectorType>(ptrSrc);
-                }
-                finally
-                {
-                    handleSrc.Free();
-                }
-
-                handleSrc = GCHandle.Alloc(y, GCHandleType.Pinned);
-
-                try
-                {
-                    var ptrSrc = (byte*) handleSrc.AddrOfPinnedObject().ToPointer();
-
-                    _vectorY = Unsafe.Read<TVectorType>(ptrSrc);
-                }
-                finally
-                {
-                    handleSrc.Free();
-                }
-            }
-
-            public static unsafe void setData(TBaseType[] x, TBaseType[] y, TBaseType[] z)
-            {
-                setData(x, y);
-                arrayZ = z;
-
-                GCHandle handleSrc = GCHandle.Alloc(z, GCHandleType.Pinned);
-
-                try
-                {
-                    var ptrSrc = (byte*) handleSrc.AddrOfPinnedObject().ToPointer();
-
-                    _vectorZ = Unsafe.Read<TVectorType>(ptrSrc);
-                }
-                finally
-                {
-                    handleSrc.Free();
-                }
-
-            }
-
-        }
-
-        static unsafe TBaseType[] writeVector<TBaseType, TVectorType>(TVectorType src)
-            where TBaseType : struct
-            where TVectorType : new()
-        {
-            var length = Unsafe.SizeOf<TVectorType>() / Unsafe.SizeOf<TBaseType>();
-            var dst = new TBaseType[length];
-
-            GCHandle handleSrc = GCHandle.Alloc(src, GCHandleType.Pinned);
-            GCHandle handleDst = GCHandle.Alloc(dst, GCHandleType.Pinned);
-
-            try
-            {
-                var ptrSrc = (byte*) handleSrc.AddrOfPinnedObject().ToPointer();
-                var ptrDst = (byte*) handleDst.AddrOfPinnedObject().ToPointer();
-
-                for (int i = 0; i < Unsafe.SizeOf<TVectorType>(); ++i)
-                {
-                    ptrDst[i] = ptrSrc[i];
-                }
-            }
-            finally
-            {
-                handleSrc.Free();
-                handleDst.Free();
-            }
-
-            return dst;
-        }
-
-        static void testCryptoOp<TBaseType, TVectorType, TBaseReturnType, TVectorReturnType>(String testCaseDescription,
-                                                      Func<TVectorType, TVectorType, TVectorType, TVectorReturnType> cryptoOp,
-                                                      TBaseType[] check)
-            where TBaseType : struct, IComparable
-            where TVectorType : new()
-            where TBaseReturnType : struct, IComparable
-            where TVectorReturnType : new()
-        {
-            bool failed = false;
-            try
-            {
-                var vX = DataSet<TBaseType, TVectorType>.vectorX;
-                var vY = DataSet<TBaseType, TVectorType>.vectorY;
-                var vZ = DataSet<TBaseType, TVectorType>.vectorZ;
-                var vResult = cryptoOp(vX, vY, vZ);
-
-                var result = writeVector<TBaseReturnType, TVectorReturnType>(vResult);
-                //Console.WriteLine("res [{0}]", string.Join(", ", result));
-
-
-                for (int i = 0; i < result.Length; i++)
-                {
-
-                    var expected = check[i];
-
-                    if (result[i].CompareTo(expected) != 0)
-                    {
-                        if(!failed)
-                        {
-                            Console.WriteLine($"testCryptoOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Check Failed");
-                        }
-                        Console.WriteLine($"check[{i}] : result[{i}] = {result[i]}, expected {expected}");
-                        failed = true;
-                    }
-                }
-            }
-            catch
-            {
-                Console.WriteLine($"testCryptoOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Unexpected exception");
-                throw;
-            }
-
-            if (failed)
-            {
-                throw new Exception($"testCryptoOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Failed");
-            }
-            else
-            {
-                Console.WriteLine($"testCryptoOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Check Passed");
-            }
-        }
-
-        static void testThrowsTypeNotSupported<TVectorType>(String testCaseDescription,
-                                                                Func<TVectorType, TVectorType, TVectorType, TVectorType> cryptoOp)
-            where TVectorType : new()
-        {
-            TVectorType v = new TVectorType();
-
-            bool notSupported = false;
-
-            try
-            {
-                cryptoOp(v,v,v);
-            }
-            catch (PlatformNotSupportedException)
-            {
-                notSupported = true;
-            }
-            finally
-            {
-                Debug.Assert(notSupported, $"{typeof(TVectorType).Name} {testCaseDescription}: Failed to throw PlatformNotSupportedException");
-            }
-        }
-
-        static void testThrowsPlatformNotSupported<TVectorType>(String testCaseDescription,
-                                                                Func<TVectorType, TVectorType, TVectorType, TVectorType> cryptoOp)
-            where TVectorType : new()
-        {
-            testThrowsPlatformNotSupported<TVectorType, TVectorType>(testCaseDescription, cryptoOp);
-        }
-
-        static void testThrowsPlatformNotSupported<TVectorType, TVectorTypeReturn>(String testCaseDescription,
-                                                                Func<TVectorType, TVectorType, TVectorType, TVectorTypeReturn> cryptoOp)
-            where TVectorType : new()
-        {
-            bool notSupported = false;
-
-            try
-            {
-                TVectorType v = new TVectorType();
-                cryptoOp(v,v,v);
-            }
-            catch (PlatformNotSupportedException) // TODO-Fixme check for Type not supported exception
-            {
-                notSupported = true;
-            }
-            finally
-            {
-                Debug.Assert(notSupported, $"{typeof(TVectorType).Name} {testCaseDescription}: Failed to throw TypeNotSupportedException");
-            }
-        }
-
-
-        static void TestAes()
-        {
-            String name = "Aes";
-
-            if (Aes.IsSupported)
-            {
-                testCryptoOp<byte,  Vector128<byte>, byte, Vector128<byte> >(name, (x, y, z) => Aes.Encrypt(x, y), aesEncRes);
-                testCryptoOp<byte,  Vector128<byte>, byte, Vector128<byte> >(name, (x, y, z) => Aes.Decrypt(x, y), aesDecRes);
-                testCryptoOp<byte,  Vector128<byte>, byte, Vector128<byte> >(name, (x, y, z) => Aes.MixColumns(x), aesMixRes );
-                testCryptoOp<byte,  Vector128<byte>, byte, Vector128<byte> >(name, (x, y, z) => Aes.InverseMixColumns(x), aesInvMixRes );
-
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector128<byte> , Vector128<byte>  >(name, (x, y, z) => Aes.Encrypt(x,y));
-                testThrowsPlatformNotSupported<Vector128<byte> , Vector128<byte>  >(name, (x, y, z) => Aes.Decrypt(x,y));
-                testThrowsPlatformNotSupported<Vector128<byte> , Vector128<byte>  >(name, (x, y, z) => Aes.MixColumns(x));
-                testThrowsPlatformNotSupported<Vector128<byte> , Vector128<byte>  >(name, (x, y, z) => Aes.InverseMixColumns(x));
-            }
-        }
-
-        static void TestSha256()
-        {
-            String name = "Sha256";
-            if (Sha256.IsSupported)
-            {
-                testCryptoOp<uint,  Vector128<uint>, uint, Vector128<uint> >(name, (x, y, z) => Sha256.HashLower(x, y, z), sha256low);
-                testCryptoOp<uint,  Vector128<uint>, uint, Vector128<uint> >(name, (x, y, z) => Sha256.HashUpper(x, y, z), sha256high);
-                testCryptoOp<uint,  Vector128<uint>, uint, Vector128<uint> >(name, (x, y, z) => Sha256.SchedulePart1(x, y), sha256su1Res);
-                testCryptoOp<uint,  Vector128<uint>, uint, Vector128<uint> >(name, (x, y, z) => Sha256.SchedulePart2(x, y, z), sha256su2Res);
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector128<uint>, Vector128<uint> >(name, (x, y, z) => Sha256.HashLower(x, y, z));
-                testThrowsPlatformNotSupported<Vector128<uint>, Vector128<uint> >(name, (x, y, z) => Sha256.HashUpper(x, y, z));
-                testThrowsPlatformNotSupported<Vector128<uint>, Vector128<uint> >(name, (x, y, z) => Sha256.SchedulePart1(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint>, Vector128<uint> >(name, (x, y, z) => Sha256.SchedulePart2(x, y, z));
-            }
-        }
-
-        static void TestSha1()
-        {
-            String name = "Sha1";
-            if (Sha1.IsSupported)
-            {
-                testCryptoOp<uint,  Vector128<uint>, uint, Vector128<uint> >(name, (x, y, z) => Sha1.HashChoose(x, 20, y), sha1cRes);
-                testCryptoOp<uint,  Vector128<uint>, uint, Vector128<uint> >(name, (x, y, z) => Sha1.HashParity(x, 20, y), sha1pRes);
-                testCryptoOp<uint,  Vector128<uint>, uint, Vector128<uint> >(name, (x, y, z) => Sha1.HashMajority(x, 20, y), sha1mRes);
-                testCryptoOp<uint,  Vector128<uint>, uint, Vector128<uint> >(name, (x, y, z) => Sha1.SchedulePart1(x, y, z), sha1su1Res);
-                testCryptoOp<uint,  Vector128<uint>, uint, Vector128<uint> >(name, (x, y, z) => Sha1.SchedulePart2(x, y), sha1su2Res);
-                if(Sha1.FixedRotate(100) != 25)
-                    throw new Exception("Sha1 FixedRotate failed.\n");
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector128<uint> , Vector128<uint>  >(name, (x, y, z) => Sha1.HashChoose(x, 20, y));
-                testThrowsPlatformNotSupported<Vector128<uint> , Vector128<uint>  >(name, (x, y, z) => Sha1.HashParity(x, 20, y));
-                testThrowsPlatformNotSupported<Vector128<uint> , Vector128<uint>  >(name, (x, y, z) => Sha1.HashMajority(x, 20, y));
-                testThrowsPlatformNotSupported<Vector128<uint> , Vector128<uint>  >(name, (x, y, z) => Sha1.SchedulePart1(x, y, z));
-                testThrowsPlatformNotSupported<Vector128<uint> , Vector128<uint>  >(name, (x, y, z) => Sha1.SchedulePart2(x, y));
-            }
-        }
-
-        static void initializeDataSetDefault()
-        {
-            /// Data sets
-            DataSet<byte, Vector128<byte> >.setData(new byte[]   { 1,  5, 100, 0, 7, 8,  2,  9, 1,  5, 100, 0, 7, 8,  2,  9 },
-                                               new byte[]  { 22,  1,  50, 0, 7, 5, 3,  33,  17, 4, 100, 120, 27, 6,  2,  6 },
-                                               new byte[]  { 1,  5,  10, 0, 17, 23, 14,  33,  15, 40, 0, 20, 22, 55,  12,  5 });
-            DataSet<uint, Vector128<uint> >.setData(new uint[] {10, 44, 11, 81}, new uint[] {20, 41, 67, 59}, new uint[] {10, 20, 51, 96});
-        }
-
-        // Below result values are obtained by executing the corresponding GCC arm64 crypto intrinsics (defined in arm_neon.h)
-        // with the same input dataset on ARM64 platform.
-
-        static byte[] aesEncRes = new byte[] {240, 215, 99, 118, 99, 124, 99, 99, 202, 171, 177, 52, 156, 242, 124, 188};
-        static byte[] aesDecRes = new byte[] {135, 215, 82, 238, 82, 48, 82, 193, 124, 243, 185, 251, 196, 09, 09, 82};
-        static byte[] aesMixRes = new byte[] {105, 167, 204, 98, 29, 24, 16, 17, 105, 167, 204, 98, 29, 24, 16, 17};
-        static byte[] aesInvMixRes = new byte[] {203, 158, 110, 91, 41, 60, 36, 53, 203, 158, 110, 91, 41, 60, 36, 53};
-        static uint[] sha1cRes = new uint[] {2162335592, 464120, 1073745449, 1073741936};
-        static uint[] sha1pRes = new uint[] {15831335, 2147977893, 3857, 2147483767};
-        static uint[] sha1mRes = new uint[] {12230250, 382193, 1073744809, 1073741916};
-        static uint[] sha1su1Res = new uint[] {11, 105, 44, 24};
-        static uint[] sha1su2Res = new uint[] {70,222,96,46};
-        static uint[] sha256low = new uint[] {3870443882, 98061066, 1597900421, 3536859796};
-        static uint[] sha256high = new uint[] {2024066181, 3259295072, 1866655758, 692061599};
-        static uint[] sha256su1Res = new uint[] {1477115919, 369279021, 2719236117, 671416403};
-        static uint[] sha256su2Res = new uint[] {2089011, 3932271, 203417658, 2151313268};
-
-
-        static void ExecuteAllTests()
-        {
-            TestAes();
-            TestSha1();
-            TestSha256();
-        }
-
-        static int Main(string[] args)
-        {
-            Console.WriteLine($"System.Runtime.Intrinsics.Arm.Arm64.Aes.IsSupported = {Aes.IsSupported}");
-            Console.WriteLine($"System.Runtime.Intrinsics.Arm.Arm64.Sha1.IsSupported = {Sha1.IsSupported}");
-            Console.WriteLine($"System.Runtime.Intrinsics.Arm.Arm64.Sha2.IsSupported = {Sha256.IsSupported}");
-            initializeDataSetDefault();
-            Console.WriteLine("Running tests");
-            ExecuteAllTests();
-
-            return 100;
-        }
-    }
-}

diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Crypto.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Crypto.csproj
deleted file mode 100644 (file)
index c7cf504..0000000
--- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Crypto.csproj
+++ /dev/null
@@ -1,13 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-  <PropertyGroup>
-    <DebugType>None</DebugType>
-    <Optimize>True</Optimize>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="Crypto.cs" />
-  </ItemGroup>
-</Project>

diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Simd.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Simd.cs
deleted file mode 100644 (file)
index ad76022..0000000
--- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Simd.cs
+++ /dev/null
@@ -1,2316 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm.Arm64;
-
-namespace Arm64intrisicsTest
-{
-    struct DataSet<TBaseType, TVectorType>
-            where TBaseType : struct
-            where TVectorType : new()
-    {
-        private static TVectorType _vectorX;
-        private static TVectorType _vectorY;
-
-        public static TVectorType vectorX { get { return _vectorX; }}
-        public static TVectorType vectorY { get { return _vectorY; }}
-
-        public static TBaseType[] arrayX { get; private set; }
-        public static TBaseType[] arrayY { get; private set; }
-
-        public static unsafe void setData(TBaseType[] x, TBaseType[] y)
-        {
-            arrayX = x;
-            arrayY = y;
-
-            GCHandle handleSrc = GCHandle.Alloc(x, GCHandleType.Pinned);
-
-            try
-            {
-                var ptrSrc = (byte*) handleSrc.AddrOfPinnedObject().ToPointer();
-
-                _vectorX = Unsafe.Read<TVectorType>(ptrSrc);
-            }
-            finally
-            {
-                handleSrc.Free();
-            }
-
-
-            handleSrc = GCHandle.Alloc(y, GCHandleType.Pinned);
-
-            try
-            {
-                var ptrSrc = (byte*) handleSrc.AddrOfPinnedObject().ToPointer();
-
-                _vectorY = Unsafe.Read<TVectorType>(ptrSrc);
-            }
-            finally
-            {
-                handleSrc.Free();
-            }
-        }
-    };
-
-    class Program
-    {
-        static unsafe TBaseType[] writeVector<TBaseType, TVectorType>(TVectorType src)
-            where TBaseType : struct
-            where TVectorType : new()
-        {
-            var length = Unsafe.SizeOf<TVectorType>() / Unsafe.SizeOf<TBaseType>();
-            var dst = new TBaseType[length];
-
-            GCHandle handleSrc = GCHandle.Alloc(src, GCHandleType.Pinned);
-            GCHandle handleDst = GCHandle.Alloc(dst, GCHandleType.Pinned);
-
-            try
-            {
-                var ptrSrc = (byte*) handleSrc.AddrOfPinnedObject().ToPointer();
-                var ptrDst = (byte*) handleDst.AddrOfPinnedObject().ToPointer();
-
-                for (int i = 0; i < Unsafe.SizeOf<TVectorType>(); ++i)
-                {
-                    ptrDst[i] = ptrSrc[i];
-                }
-            }
-            finally
-            {
-                handleSrc.Free();
-                handleDst.Free();
-            }
-
-            return dst;
-        }
-
-        static void testBinOp<TBaseType, TVectorType>(String testCaseDescription,
-                                                      Func<TVectorType, TVectorType, TVectorType> binOp,
-                                                      Func<TBaseType, TBaseType, TBaseType> check)
-            where TBaseType : struct, IComparable
-            where TVectorType : new()
-        {
-            testBinOp<TBaseType, TVectorType, TBaseType, TVectorType>(testCaseDescription, binOp, check);
-        }
-
-        static void dumpVector<TBaseType, TVectorType>(String name, TVectorType vector)
-            where TBaseType : struct, IComparable
-            where TVectorType : new()
-        {
-            var result = writeVector<TBaseType, TVectorType>(vector);
-
-            Console.Write(name);
-            Console.Write(" : { ");
-            for (int i = 0; i < result.Length; i++)
-            {
-                Console.Write($"{result[i]} ");
-            }
-            Console.WriteLine("}");
-        }
-
-        static void testBinOp<TBaseType, TVectorType, TBaseReturnType, TVectorReturnType>(String testCaseDescription,
-                                                      Func<TVectorType, TVectorType, TVectorReturnType> binOp,
-                                                      Func<TBaseType, TBaseType, TBaseReturnType> check)
-            where TBaseType : struct, IComparable
-            where TVectorType : new()
-            where TBaseReturnType : struct, IComparable
-            where TVectorReturnType : new()
-        {
-            bool failed = false;
-            try
-            {
-                var vLeft  = DataSet<TBaseType, TVectorType>.vectorX;
-                var vRight = DataSet<TBaseType, TVectorType>.vectorY;
-
-                var vResult = binOp(vLeft, vRight);
-
-                var result = writeVector<TBaseReturnType, TVectorReturnType>(vResult);
-
-                var left   = DataSet<TBaseType, TVectorType>.arrayX;
-                var right  = DataSet<TBaseType, TVectorType>.arrayY;
-
-                for (int i = 0; i < result.Length; i++)
-                {
-                    var expected = check(left[i], right[i]);
-
-                    if (result[i].CompareTo(expected) != 0)
-                    {
-                        if(!failed)
-                        {
-                            Console.WriteLine($"testBinOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Check Failed");
-                            dumpVector<TBaseType, TVectorType>("vLeft", vLeft);
-                            dumpVector<TBaseType, TVectorType>("vRight", vRight);
-                            dumpVector<TBaseReturnType, TVectorReturnType>("vResult", vResult);
-                        }
-                        Console.WriteLine($"check({left[i]}, {right[i]}) : result[{i}] = {result[i]}, expected {expected}");
-                        failed = true;
-                    }
-                }
-            }
-            catch
-            {
-                Console.WriteLine($"testBinOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Unexpected exception");
-                throw;
-            }
-
-            if (failed)
-            {
-                throw new Exception($"testBinOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Failed");
-            }
-        }
-
-        static void testExtractOp<TBaseType, TVectorType>(String testCaseDescription,
-                                                      Func<TVectorType, TBaseType> extractOp,
-                                                      Func<TBaseType[], TBaseType> check)
-            where TBaseType : struct, IComparable
-            where TVectorType : new()
-        {
-            bool failed = false;
-            try
-            {
-                var vLeft  = DataSet<TBaseType, TVectorType>.vectorX;
-
-                var vResult = extractOp(vLeft);
-
-                var left   = DataSet<TBaseType, TVectorType>.arrayX;
-
-                var expected = check(left);
-
-                if (vResult.CompareTo(expected) != 0)
-                {
-                    if(!failed)
-                    {
-                        Console.WriteLine($"testExtractOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Check Failed");
-                    }
-                    Console.WriteLine($"check(left) : vResult = {vResult}, expected {expected}");
-                    failed = true;
-                }
-            }
-            catch
-            {
-                Console.WriteLine($"testBinOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Unexpected exception");
-                throw;
-            }
-
-            if (failed)
-            {
-                throw new Exception($"testBinOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Failed");
-            }
-        }
-
-        static void testPermuteOp<TBaseType, TVectorType>(String testCaseDescription,
-                                                      Func<TVectorType, TVectorType, TVectorType> binOp,
-                                                      Func<int, TBaseType[], TBaseType[], TBaseType> check)
-            where TBaseType : struct, IComparable
-            where TVectorType : new()
-        {
-            bool failed = false;
-            try
-            {
-                var vLeft  = DataSet<TBaseType, TVectorType>.vectorX;
-                var vRight = DataSet<TBaseType, TVectorType>.vectorY;
-
-                var vResult = binOp(vLeft, vRight);
-
-                var result = writeVector<TBaseType, TVectorType>(vResult);
-
-                var left   = DataSet<TBaseType, TVectorType>.arrayX;
-                var right  = DataSet<TBaseType, TVectorType>.arrayY;
-
-                for (int i = 0; i < result.Length; i++)
-                {
-                    var expected = check(i, left, right);
-
-                    if (result[i].CompareTo(expected) != 0)
-                    {
-                        if(!failed)
-                        {
-                            Console.WriteLine($"testPermuteOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Check Failed");
-                        }
-                        Console.WriteLine($"check({left[i]}, {right[i]}) : result[{i}] = {result[i]}, expected {expected}");
-                        failed = true;
-                    }
-                }
-            }
-            catch
-            {
-                Console.WriteLine($"testPermuteOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Unexpected exception");
-                throw;
-            }
-
-            if (failed)
-            {
-                throw new Exception($"testPermuteOp<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Failed");
-            }
-        }
-
-        static void testThrowsArgumentOutOfRangeException<TBaseType, TVectorType>(String testCaseDescription,
-                                                                Func<TVectorType, TVectorType, TBaseType> binOp)
-            where TBaseType : struct
-            where TVectorType : struct
-        {
-            testThrowsArgumentOutOfRangeException<TBaseType, TVectorType, TBaseType>(testCaseDescription, binOp);
-        }
-
-        static void testThrowsArgumentOutOfRangeException<TBaseType, TVectorType, TReturnType>(String testCaseDescription,
-                                                                Func<TVectorType, TVectorType, TReturnType> binOp)
-            where TBaseType : struct
-            where TVectorType : struct
-            where TReturnType : struct
-        {
-            var v = DataSet<TBaseType, TVectorType>.vectorX;
-
-            bool caughtArgRangeEx = false;
-
-            try
-            {
-                binOp(v,v);
-            }
-            catch (ArgumentOutOfRangeException)
-            {
-                caughtArgRangeEx = true;
-            }
-            catch
-            {
-                Console.WriteLine($"testThrowsArgumentOutOfRangeException: Unexpected exception");
-                throw;
-            }
-
-            if (caughtArgRangeEx == false)
-            {
-                throw new Exception($"testThrowsArgumentOutOfRangeException<{typeof(TBaseType).Name}, {typeof(TVectorType).Name} >{testCaseDescription}: Failed");
-            }
-        }
-
-        static void testThrowsTypeNotSupported<TVectorType>(String testCaseDescription,
-                                                                Func<TVectorType, TVectorType, TVectorType> binOp)
-            where TVectorType : new()
-        {
-            TVectorType v = new TVectorType();
-
-            bool notSupported = false;
-
-            try
-            {
-                binOp(v,v);
-            }
-            catch (NotSupportedException e)
-            {
-                notSupported = true;
-            }
-            catch
-            {
-                Console.WriteLine($"testThrowsTypeNotSupported: Unexpected exception");
-                throw;
-            }
-
-            if (notSupported == false)
-            {
-                throw new Exception($"testThrowsTypeNotSupported<{typeof(TVectorType).Name} >{testCaseDescription}: Failed");
-            }
-        }
-
-        static void testThrowsPlatformNotSupported<TVectorType>(String testCaseDescription,
-                                                                Func<TVectorType, TVectorType, TVectorType> binOp)
-            where TVectorType : new()
-        {
-            testThrowsPlatformNotSupported<TVectorType, TVectorType>(testCaseDescription, binOp);
-        }
-
-        static void testThrowsPlatformNotSupported<TVectorType, TVectorTypeReturn>(String testCaseDescription,
-                                                                Func<TVectorType, TVectorType, TVectorTypeReturn> binOp)
-            where TVectorType : new()
-        {
-            TVectorType v = new TVectorType();
-
-            bool notSupported = false;
-
-            try
-            {
-                binOp(v,v);
-            }
-            catch (PlatformNotSupportedException)
-            {
-                notSupported = true;
-            }
-            catch
-            {
-                Console.WriteLine($"testThrowsPlatformNotSupported: Unexpected exception");
-                throw;
-            }
-
-            if (notSupported == false)
-            {
-                throw new Exception($"testThrowsPlatformNotSupported<{typeof(TVectorType).Name} >{testCaseDescription}: Failed");
-            }
-        }
-
-        static uint bits(float x)
-        {
-            return BitConverter.ToUInt32(BitConverter.GetBytes(x));
-        }
-
-        static ulong bits(double x)
-        {
-            return BitConverter.ToUInt64(BitConverter.GetBytes(x));
-        }
-
-        static float bitsToFloat(uint x)
-        {
-            return BitConverter.ToSingle(BitConverter.GetBytes(x));
-        }
-
-        static double bitsToDouble(ulong x)
-        {
-            return BitConverter.ToDouble(BitConverter.GetBytes(x));
-        }
-
-        static ulong bitsToUint64<T>(T x)
-        {
-            return Unsafe.As<T, ulong>(ref x) & ~(~0UL << 8*Unsafe.SizeOf<T>());
-        }
-
-        static T boolTo<T>(bool x)
-            where T : IConvertible
-        {
-            ulong result = x ? ~0UL : 0UL;
-
-            if (typeof(T) == typeof(double)) return (T) Convert.ChangeType(     bitsToDouble(result), typeof(T));
-            if (typeof(T) == typeof(float))  return (T) Convert.ChangeType(bitsToFloat((uint)result), typeof(T));
-            if (typeof(T) == typeof(byte)  ) return (T) Convert.ChangeType(          (byte)  result,  typeof(T));
-            if (typeof(T) == typeof(sbyte) ) return (T) Convert.ChangeType(          (sbyte) result,  typeof(T));
-            if (typeof(T) == typeof(ushort)) return (T) Convert.ChangeType(          (ushort)result,  typeof(T));
-            if (typeof(T) == typeof(short) ) return (T) Convert.ChangeType(          (short) result,  typeof(T));
-            if (typeof(T) == typeof(uint)  ) return (T) Convert.ChangeType(          (uint)  result,  typeof(T));
-            if (typeof(T) == typeof(int)   ) return (T) Convert.ChangeType(          (int)   result,  typeof(T));
-            if (typeof(T) == typeof(ulong) ) return (T) Convert.ChangeType(          (ulong) result,  typeof(T));
-            if (typeof(T) == typeof(long)  ) return (T) Convert.ChangeType(          (long)  result,  typeof(T));
-
-            throw new Exception("Unexpected Type");
-        }
-
-        static T popCount<T>(T x)
-            where T : IConvertible
-        {
-            ulong result = 0;
-            ulong value = bitsToUint64(x);
-
-            while(value != 0)
-            {
-                result++;
-                value = value & (value - 1);
-            }
-
-            return (T) Convert.ChangeType(result, typeof(T));
-
-            throw new Exception("Unexpected Type");
-        }
-
-        static T leadingZero<T>(T x)
-            where T : IConvertible
-        {
-            ulong compare = 0x1UL << (8*Unsafe.SizeOf<T>() - 1);
-            ulong result = 0;
-            ulong value = bitsToUint64(x);
-
-            while(value < compare)
-            {
-                result++;
-                compare >>= 1;
-            }
-
-            return (T) Convert.ChangeType(result,  typeof(T));
-
-            throw new Exception("Unexpected Type");
-        }
-
-        static T leadingSign<T>(T x)
-            where T : IConvertible
-        {
-            ulong value = bitsToUint64(x);
-            ulong signBit = value & (0x1UL << (8*Unsafe.SizeOf<T>() - 1));
-            ulong result = 0;
-
-            if (signBit == 0)
-            {
-                result = (ulong) Convert.ChangeType(leadingZero(x), typeof(ulong));
-            }
-            else
-            {
-                result = (ulong) Convert.ChangeType(leadingZero((T) Convert.ChangeType(value ^ (signBit + (signBit - 1)),  typeof(T))), typeof(ulong));
-            }
-
-            return (T) Convert.ChangeType(result - 1, typeof(T));
-        }
-
-        static void TestAbs()
-        {
-            String name = "Abs";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float> , float,  Vector128<float >>(name, (x, y) => Simd.Abs(x), (x, y) =>          Math.Abs(x));
-                testBinOp<double, Vector128<double>, double, Vector128<double>>(name, (x, y) => Simd.Abs(x), (x, y) =>          Math.Abs(x));
-                testBinOp<sbyte,  Vector128<sbyte> , byte,   Vector128<byte  >>(name, (x, y) => Simd.Abs(x), (x, y) => (byte)   Math.Abs(x));
-                testBinOp<short,  Vector128<short> , ushort, Vector128<ushort>>(name, (x, y) => Simd.Abs(x), (x, y) => (ushort) Math.Abs(x));
-                testBinOp<int,    Vector128<int>   , uint,   Vector128<uint  >>(name, (x, y) => Simd.Abs(x), (x, y) => (uint)   Math.Abs(x));
-                testBinOp<long,   Vector128<long>  , ulong,  Vector128<ulong >>(name, (x, y) => Simd.Abs(x), (x, y) => (ulong)  Math.Abs(x));
-                testBinOp<float,  Vector64<float>  , float,  Vector64< float >>(name, (x, y) => Simd.Abs(x), (x, y) =>          Math.Abs(x));
-                testBinOp<sbyte,  Vector64<sbyte>  , byte,   Vector64< byte  >>(name, (x, y) => Simd.Abs(x), (x, y) => (byte)   Math.Abs(x));
-                testBinOp<short,  Vector64<short>  , ushort, Vector64< ushort>>(name, (x, y) => Simd.Abs(x), (x, y) => (ushort) Math.Abs(x));
-                testBinOp<int,    Vector64<int>    , uint,   Vector64< uint  >>(name, (x, y) => Simd.Abs(x), (x, y) => (uint)   Math.Abs(x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64<float>  , Vector64< float >>(name, (x, y) => Simd.Abs(x));
-                testThrowsPlatformNotSupported<Vector64<sbyte>  , Vector64< byte  >>(name, (x, y) => Simd.Abs(x));
-                testThrowsPlatformNotSupported<Vector64<short>  , Vector64< ushort>>(name, (x, y) => Simd.Abs(x));
-                testThrowsPlatformNotSupported<Vector64<int>    , Vector64< uint  >>(name, (x, y) => Simd.Abs(x));
-                testThrowsPlatformNotSupported<Vector128<float> , Vector128<float >>(name, (x, y) => Simd.Abs(x));
-                testThrowsPlatformNotSupported<Vector128<double>, Vector128<double>>(name, (x, y) => Simd.Abs(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte> , Vector128<byte  >>(name, (x, y) => Simd.Abs(x));
-                testThrowsPlatformNotSupported<Vector128<short> , Vector128<ushort>>(name, (x, y) => Simd.Abs(x));
-                testThrowsPlatformNotSupported<Vector128<int>   , Vector128<uint  >>(name, (x, y) => Simd.Abs(x));
-                testThrowsPlatformNotSupported<Vector128<long>  , Vector128<ulong >>(name, (x, y) => Simd.Abs(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestAdd()
-        {
-            String name = "Add";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Add(x, y), (x, y) =>         (x + y));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Add(x, y), (x, y) =>         (x + y));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Add(x, y), (x, y) => (sbyte) (x + y));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.Add(x, y), (x, y) => (byte)  (x + y));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.Add(x, y), (x, y) => (short) (x + y));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.Add(x, y), (x, y) => (ushort)(x + y));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.Add(x, y), (x, y) =>         (x + y));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.Add(x, y), (x, y) =>         (x + y));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.Add(x, y), (x, y) =>         (x + y));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.Add(x, y), (x, y) =>         (x + y));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Add(x, y), (x, y) =>         (x + y));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Add(x, y), (x, y) => (sbyte) (x + y));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.Add(x, y), (x, y) => (byte)  (x + y));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.Add(x, y), (x, y) => (short) (x + y));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.Add(x, y), (x, y) => (ushort)(x + y));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.Add(x, y), (x, y) =>         (x + y));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.Add(x, y), (x, y) =>         (x + y));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.Add(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.Add(x, y));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.Add(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.Add(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.Add(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestAnd()
-        {
-            String name = "And";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.And(x, y), (x, y) => bitsToFloat (bits(x) & bits(y)));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.And(x, y), (x, y) => bitsToDouble(bits(x) & bits(y)));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.And(x, y), (x, y) => (sbyte)     (     x  &      y ));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.And(x, y), (x, y) => (byte)      (     x  &      y ));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.And(x, y), (x, y) => (short)     (     x  &      y ));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.And(x, y), (x, y) => (ushort)    (     x  &      y ));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.And(x, y), (x, y) =>             (     x  &      y ));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.And(x, y), (x, y) =>             (     x  &      y ));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.And(x, y), (x, y) =>             (     x  &      y ));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.And(x, y), (x, y) =>             (     x  &      y ));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.And(x, y), (x, y) => bitsToFloat (bits(x) & bits(y)));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.And(x, y), (x, y) => (sbyte)     (     x  &      y ));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.And(x, y), (x, y) => (byte)      (     x  &      y ));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.And(x, y), (x, y) => (short)     (     x  &      y ));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.And(x, y), (x, y) => (ushort)    (     x  &      y ));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.And(x, y), (x, y) =>             (     x  &      y ));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.And(x, y), (x, y) =>             (     x  &      y ));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.And(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long  >>(name, (x, y) => Simd.And(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong >>(name, (x, y) => Simd.And(x, y));
-                testThrowsTypeNotSupported<Vector64< double>>(name, (x, y) => Simd.And(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.And(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.And(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestAndNot()
-        {
-            String name = "AndNot";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.AndNot(x, y), (x, y) => bitsToFloat (bits(x) & ~bits(y)));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.AndNot(x, y), (x, y) => bitsToDouble(bits(x) & ~bits(y)));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.AndNot(x, y), (x, y) => (sbyte)     (     x  & ~     y ));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.AndNot(x, y), (x, y) => (byte)      (     x  & ~     y ));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.AndNot(x, y), (x, y) => (short)     (     x  & ~     y ));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.AndNot(x, y), (x, y) => (ushort)    (     x  & ~     y ));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.AndNot(x, y), (x, y) =>             (     x  & ~     y ));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.AndNot(x, y), (x, y) =>             (     x  & ~     y ));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.AndNot(x, y), (x, y) =>             (     x  & ~     y ));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.AndNot(x, y), (x, y) =>             (     x  & ~     y ));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.AndNot(x, y), (x, y) => bitsToFloat (bits(x) & ~bits(y)));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.AndNot(x, y), (x, y) => (sbyte)     (     x  & ~     y ));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.AndNot(x, y), (x, y) => (byte)      (     x  & ~     y ));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.AndNot(x, y), (x, y) => (short)     (     x  & ~     y ));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.AndNot(x, y), (x, y) => (ushort)    (     x  & ~     y ));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.AndNot(x, y), (x, y) =>             (     x  & ~     y ));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.AndNot(x, y), (x, y) =>             (     x  & ~     y ));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.AndNot(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.AndNot(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.AndNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.AndNot(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestBitwiseSelect()
-        {
-            String name = "BitwiseSelect";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => bitsToFloat (bits(y) ^ (bits(x + y) & (bits(x) ^ bits(y)))));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => bitsToDouble(bits(y) ^ (bits(x + y) & (bits(x) ^ bits(y)))));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => (sbyte)     (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => (byte)      (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => (short)     (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => (ushort)    (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) =>             (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) =>             (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) =>             (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) =>             (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => bitsToFloat (bits(y) ^ (bits(x + y) & (bits(x) ^ bits(y)))));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => (sbyte)     (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => (byte)      (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => (short)     (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) => (ushort)    (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) =>             (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.BitwiseSelect(Simd.Add(x,y), x, y), (x, y) =>             (    (y) ^ (    (x + y) & (    (x) ^     (y)))));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.BitwiseSelect(x, x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestCompareEqual()
-        {
-            String name = "CompareEqual";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<float >(x == y));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<double>(x == y));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<sbyte >(x == y));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<byte  >(x == y));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<short >(x == y));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<ushort>(x == y));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<int   >(x == y));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<uint  >(x == y));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<long  >(x == y));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<ulong >(x == y));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<float >(x == y));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<sbyte >(x == y));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<byte  >(x == y));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<short >(x == y));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<ushort>(x == y));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<int   >(x == y));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.CompareEqual(x, y), (x, y) => boolTo<uint  >(x == y));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.CompareEqual(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.CompareEqual(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.CompareEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.CompareEqual(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestCompareEqualZero()
-        {
-            String name = "CompareEqualZero";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<float >(x == 0));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<double>(x == 0));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<sbyte >(x == 0));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<byte  >(x == 0));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<short >(x == 0));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<ushort>(x == 0));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<int   >(x == 0));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<uint  >(x == 0));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<long  >(x == 0));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<ulong >(x == 0));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<float >(x == 0));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<sbyte >(x == 0));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<byte  >(x == 0));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<short >(x == 0));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<ushort>(x == 0));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<int   >(x == 0));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.CompareEqualZero(x), (x, y) => boolTo<uint  >(x == 0));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.CompareEqualZero(x));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.CompareEqualZero(x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.CompareEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.CompareEqualZero(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestCompareGreaterThan()
-        {
-            String name = "CompareGreaterThan";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<float >(x > y));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<double>(x > y));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<sbyte >(x > y));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<byte  >(x > y));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<short >(x > y));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<ushort>(x > y));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<int   >(x > y));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<uint  >(x > y));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<long  >(x > y));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<ulong >(x > y));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<float >(x > y));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<sbyte >(x > y));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<byte  >(x > y));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<short >(x > y));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<ushort>(x > y));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<int   >(x > y));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.CompareGreaterThan(x, y), (x, y) => boolTo<uint  >(x > y));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.CompareGreaterThan(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestCompareGreaterThanZero()
-        {
-            String name = "CompareGreaterThanZero";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<float >(x > 0));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<double>(x > 0));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<sbyte >(x > 0));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<byte  >(x > 0));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<short >(x > 0));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<ushort>(x > 0));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<int   >(x > 0));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<uint  >(x > 0));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<long  >(x > 0));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<ulong >(x > 0));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<float >(x > 0));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<sbyte >(x > 0));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<byte  >(x > 0));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<short >(x > 0));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<ushort>(x > 0));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<int   >(x > 0));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.CompareGreaterThanZero(x), (x, y) => boolTo<uint  >(x > 0));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.CompareGreaterThanZero(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestCompareGreaterThanOrEqual()
-        {
-            String name = "CompareGreaterThanOrEqual";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<float >(x >= y));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<double>(x >= y));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<sbyte >(x >= y));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<byte  >(x >= y));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<short >(x >= y));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<ushort>(x >= y));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<int   >(x >= y));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<uint  >(x >= y));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<long  >(x >= y));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<ulong >(x >= y));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<float >(x >= y));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<sbyte >(x >= y));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<byte  >(x >= y));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<short >(x >= y));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<ushort>(x >= y));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<int   >(x >= y));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y), (x, y) => boolTo<uint  >(x >= y));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.CompareGreaterThanOrEqual(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestCompareGreaterThanOrEqualZero()
-        {
-            String name = "CompareGreaterThanOrEqualZero";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<float >(x >= 0));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<double>(x >= 0));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<sbyte >(x >= 0));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<byte  >(x >= 0));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<short >(x >= 0));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<ushort>(x >= 0));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<int   >(x >= 0));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<uint  >(x >= 0));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<long  >(x >= 0));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<ulong >(x >= 0));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<float >(x >= 0));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<sbyte >(x >= 0));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<byte  >(x >= 0));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<short >(x >= 0));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<ushort>(x >= 0));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<int   >(x >= 0));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x), (x, y) => boolTo<uint  >(x >= 0));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.CompareGreaterThanOrEqualZero(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestCompareLessThanZero()
-        {
-            String name = "CompareLessThanZero";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<float >(x < 0));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<double>(x < 0));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<sbyte >(x < 0));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<byte  >(x < 0));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<short >(x < 0));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<ushort>(x < 0));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<int   >(x < 0));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<uint  >(x < 0));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<long  >(x < 0));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<ulong >(x < 0));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<float >(x < 0));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<sbyte >(x < 0));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<byte  >(x < 0));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<short >(x < 0));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<ushort>(x < 0));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<int   >(x < 0));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.CompareLessThanZero(x), (x, y) => boolTo<uint  >(x < 0));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.CompareLessThanZero(x));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.CompareLessThanZero(x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.CompareLessThanZero(x));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.CompareLessThanZero(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestCompareLessThanOrEqualZero()
-        {
-            String name = "CompareLessThanOrEqualZero";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<float >(x <= 0));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<double>(x <= 0));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<sbyte >(x <= 0));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<byte  >(x <= 0));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<short >(x <= 0));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<ushort>(x <= 0));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<int   >(x <= 0));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<uint  >(x <= 0));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<long  >(x <= 0));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<ulong >(x <= 0));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<float >(x <= 0));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<sbyte >(x <= 0));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<byte  >(x <= 0));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<short >(x <= 0));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<ushort>(x <= 0));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<int   >(x <= 0));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x), (x, y) => boolTo<uint  >(x <= 0));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.CompareLessThanOrEqualZero(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestCompareTest()
-        {
-            String name = "CompareTest";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<float >((bits(x) & bits(y)) != 0));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<double>((bits(x) & bits(y)) != 0));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<sbyte >((    (x) &     (y)) != 0));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<byte  >((    (x) &     (y)) != 0));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<short >((    (x) &     (y)) != 0));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<ushort>((    (x) &     (y)) != 0));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<int   >((    (x) &     (y)) != 0));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<uint  >((    (x) &     (y)) != 0));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<long  >((    (x) &     (y)) != 0));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<ulong >((    (x) &     (y)) != 0));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<float >((bits(x) & bits(y)) != 0));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<sbyte >((    (x) &     (y)) != 0));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<byte  >((    (x) &     (y)) != 0));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<short >((    (x) &     (y)) != 0));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<ushort>((    (x) &     (y)) != 0));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<int   >((    (x) &     (y)) != 0));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.CompareTest(x, y), (x, y) => boolTo<uint  >((    (x) &     (y)) != 0));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.CompareTest(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.CompareTest(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.CompareTest(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.CompareTest(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestDivide()
-        {
-            String name = "Divide";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Divide(x, y), (x, y) =>         (x / y));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Divide(x, y), (x, y) =>         (x / y));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Divide(x, y), (x, y) =>         (x / y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Divide(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Divide(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Divide(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        [MethodImplAttribute(MethodImplOptions.NoInlining)]
-        static T simdExtract<T>(Vector64<T> vector, byte index)
-            where T : struct
-        {
-            return Simd.Extract<T>(vector, index);
-        }
-
-        [MethodImplAttribute(MethodImplOptions.NoInlining)]
-        static T simdExtract<T>(Vector128<T> vector, byte index)
-            where T : struct
-        {
-            return Simd.Extract<T>(vector, index);
-        }
-
-        static void TestExtract()
-        {
-            String name = "Extract";
-
-            if (Simd.IsSupported)
-            {
-                testExtractOp<float,  Vector128<float >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<float,  Vector128<float >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<float,  Vector128<float >>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<float,  Vector128<float >>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<double, Vector128<double>>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<double, Vector128<double>>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x, 4), (x) => x[ 4]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x, 5), (x) => x[ 5]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x, 6), (x) => x[ 6]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x, 7), (x) => x[ 7]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x, 8), (x) => x[ 8]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x, 9), (x) => x[ 9]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x,10), (x) => x[10]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x,11), (x) => x[11]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x,12), (x) => x[12]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x,13), (x) => x[13]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x,14), (x) => x[14]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => Simd.Extract(x,15), (x) => x[15]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x, 4), (x) => x[ 4]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x, 5), (x) => x[ 5]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x, 6), (x) => x[ 6]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x, 7), (x) => x[ 7]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x, 8), (x) => x[ 8]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x, 9), (x) => x[ 9]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x,10), (x) => x[10]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x,11), (x) => x[11]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x,12), (x) => x[12]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x,13), (x) => x[13]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x,14), (x) => x[14]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => Simd.Extract(x,15), (x) => x[15]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => Simd.Extract(x, 4), (x) => x[ 4]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => Simd.Extract(x, 5), (x) => x[ 5]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => Simd.Extract(x, 6), (x) => x[ 6]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => Simd.Extract(x, 7), (x) => x[ 7]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => Simd.Extract(x, 4), (x) => x[ 4]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => Simd.Extract(x, 5), (x) => x[ 5]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => Simd.Extract(x, 6), (x) => x[ 6]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => Simd.Extract(x, 7), (x) => x[ 7]);
-                testExtractOp<int,    Vector128<int   >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<int,    Vector128<int   >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<int,    Vector128<int   >>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<int,    Vector128<int   >>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<uint,   Vector128<uint  >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<uint,   Vector128<uint  >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<uint,   Vector128<uint  >>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<uint,   Vector128<uint  >>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<long,   Vector128<long  >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<long,   Vector128<long  >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<ulong,  Vector128<ulong >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<ulong,  Vector128<ulong >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<float,  Vector64< float >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<float,  Vector64< float >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => Simd.Extract(x, 4), (x) => x[ 4]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => Simd.Extract(x, 5), (x) => x[ 5]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => Simd.Extract(x, 6), (x) => x[ 6]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => Simd.Extract(x, 7), (x) => x[ 7]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => Simd.Extract(x, 4), (x) => x[ 4]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => Simd.Extract(x, 5), (x) => x[ 5]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => Simd.Extract(x, 6), (x) => x[ 6]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => Simd.Extract(x, 7), (x) => x[ 7]);
-                testExtractOp<short,  Vector64< short >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<short,  Vector64< short >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<short,  Vector64< short >>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<short,  Vector64< short >>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<ushort, Vector64< ushort>>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<ushort, Vector64< ushort>>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<ushort, Vector64< ushort>>(name, (x) => Simd.Extract(x, 2), (x) => x[ 2]);
-                testExtractOp<ushort, Vector64< ushort>>(name, (x) => Simd.Extract(x, 3), (x) => x[ 3]);
-                testExtractOp<int,    Vector64< int   >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<int,    Vector64< int   >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-                testExtractOp<uint,   Vector64< uint  >>(name, (x) => Simd.Extract(x, 0), (x) => x[ 0]);
-                testExtractOp<uint,   Vector64< uint  >>(name, (x) => Simd.Extract(x, 1), (x) => x[ 1]);
-
-                // Test non-constant call
-                testExtractOp<float,  Vector128<float >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<float,  Vector128<float >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<float,  Vector128<float >>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<float,  Vector128<float >>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<double, Vector128<double>>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<double, Vector128<double>>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x, 4), (x) => x[ 4]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x, 5), (x) => x[ 5]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x, 6), (x) => x[ 6]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x, 7), (x) => x[ 7]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x, 8), (x) => x[ 8]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x, 9), (x) => x[ 9]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x,10), (x) => x[10]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x,11), (x) => x[11]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x,12), (x) => x[12]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x,13), (x) => x[13]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x,14), (x) => x[14]);
-                testExtractOp<sbyte,  Vector128<sbyte >>(name, (x) => simdExtract(x,15), (x) => x[15]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x, 4), (x) => x[ 4]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x, 5), (x) => x[ 5]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x, 6), (x) => x[ 6]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x, 7), (x) => x[ 7]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x, 8), (x) => x[ 8]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x, 9), (x) => x[ 9]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x,10), (x) => x[10]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x,11), (x) => x[11]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x,12), (x) => x[12]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x,13), (x) => x[13]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x,14), (x) => x[14]);
-                testExtractOp<byte,   Vector128<byte  >>(name, (x) => simdExtract(x,15), (x) => x[15]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => simdExtract(x, 4), (x) => x[ 4]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => simdExtract(x, 5), (x) => x[ 5]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => simdExtract(x, 6), (x) => x[ 6]);
-                testExtractOp<short,  Vector128<short >>(name, (x) => simdExtract(x, 7), (x) => x[ 7]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => simdExtract(x, 4), (x) => x[ 4]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => simdExtract(x, 5), (x) => x[ 5]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => simdExtract(x, 6), (x) => x[ 6]);
-                testExtractOp<ushort, Vector128<ushort>>(name, (x) => simdExtract(x, 7), (x) => x[ 7]);
-                testExtractOp<int,    Vector128<int   >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<int,    Vector128<int   >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<int,    Vector128<int   >>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<int,    Vector128<int   >>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<uint,   Vector128<uint  >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<uint,   Vector128<uint  >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<uint,   Vector128<uint  >>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<uint,   Vector128<uint  >>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<long,   Vector128<long  >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<long,   Vector128<long  >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<ulong,  Vector128<ulong >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<ulong,  Vector128<ulong >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<float,  Vector64< float >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<float,  Vector64< float >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => simdExtract(x, 4), (x) => x[ 4]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => simdExtract(x, 5), (x) => x[ 5]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => simdExtract(x, 6), (x) => x[ 6]);
-                testExtractOp<sbyte,  Vector64< sbyte >>(name, (x) => simdExtract(x, 7), (x) => x[ 7]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => simdExtract(x, 4), (x) => x[ 4]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => simdExtract(x, 5), (x) => x[ 5]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => simdExtract(x, 6), (x) => x[ 6]);
-                testExtractOp<byte,   Vector64< byte  >>(name, (x) => simdExtract(x, 7), (x) => x[ 7]);
-                testExtractOp<short,  Vector64< short >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<short,  Vector64< short >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<short,  Vector64< short >>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<short,  Vector64< short >>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<ushort, Vector64< ushort>>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<ushort, Vector64< ushort>>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<ushort, Vector64< ushort>>(name, (x) => simdExtract(x, 2), (x) => x[ 2]);
-                testExtractOp<ushort, Vector64< ushort>>(name, (x) => simdExtract(x, 3), (x) => x[ 3]);
-                testExtractOp<int,    Vector64< int   >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<int,    Vector64< int   >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-                testExtractOp<uint,   Vector64< uint  >>(name, (x) => simdExtract(x, 0), (x) => x[ 0]);
-                testExtractOp<uint,   Vector64< uint  >>(name, (x) => simdExtract(x, 1), (x) => x[ 1]);
-
-                testThrowsArgumentOutOfRangeException<float,  Vector128<float >>(name, (x, y) => Simd.Extract(x, 4));
-                testThrowsArgumentOutOfRangeException<double, Vector128<double>>(name, (x, y) => Simd.Extract(x, 2));
-                testThrowsArgumentOutOfRangeException<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Extract(x,16));
-                testThrowsArgumentOutOfRangeException<byte,   Vector128<byte  >>(name, (x, y) => Simd.Extract(x,16));
-                testThrowsArgumentOutOfRangeException<short,  Vector128<short >>(name, (x, y) => Simd.Extract(x, 8));
-                testThrowsArgumentOutOfRangeException<ushort, Vector128<ushort>>(name, (x, y) => Simd.Extract(x, 8));
-                testThrowsArgumentOutOfRangeException<int,    Vector128<int   >>(name, (x, y) => Simd.Extract(x, 4));
-                testThrowsArgumentOutOfRangeException<uint,   Vector128<uint  >>(name, (x, y) => Simd.Extract(x, 4));
-                testThrowsArgumentOutOfRangeException<long,   Vector128<long  >>(name, (x, y) => Simd.Extract(x, 2));
-                testThrowsArgumentOutOfRangeException<ulong,  Vector128<ulong >>(name, (x, y) => Simd.Extract(x, 2));
-                testThrowsArgumentOutOfRangeException<float,  Vector64< float >>(name, (x, y) => Simd.Extract(x, 2));
-                testThrowsArgumentOutOfRangeException<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Extract(x, 8));
-                testThrowsArgumentOutOfRangeException<byte,   Vector64< byte  >>(name, (x, y) => Simd.Extract(x, 8));
-                testThrowsArgumentOutOfRangeException<short,  Vector64< short >>(name, (x, y) => Simd.Extract(x, 4));
-                testThrowsArgumentOutOfRangeException<ushort, Vector64< ushort>>(name, (x, y) => Simd.Extract(x, 4));
-                testThrowsArgumentOutOfRangeException<int,    Vector64< int   >>(name, (x, y) => Simd.Extract(x, 2));
-                testThrowsArgumentOutOfRangeException<uint,   Vector64< uint  >>(name, (x, y) => Simd.Extract(x, 2));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => { return Simd.Extract(x, 1) > 1 ? x : y; });
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => { return Simd.Extract(x, 1) > 1 ? x : y; });
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => { return Simd.Extract(x, 1) > 1 ? x : y; });
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64<float>  , float >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector64<double> , double>(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector64<sbyte>  , sbyte >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector64<byte>   , byte  >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector64<short>  , short >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector64<ushort> , ushort>(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector64<int>    , int   >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector64<uint>   , uint  >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector64<long>   , long  >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector64<ulong>  , ulong >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector128<float> , float >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector128<double>, double>(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector128<sbyte> , sbyte >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector128<byte>  , byte  >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector128<short> , short >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector128<ushort>, ushort>(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector128<int>   , int   >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector128<uint>  , uint  >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector128<long>  , long  >(name, (x, y) => Simd.Extract(x, 1));
-                testThrowsPlatformNotSupported<Vector128<ulong> , ulong >(name, (x, y) => Simd.Extract(x, 1));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestInsert()
-        {
-            String name = "Insert";
-
-            if (Simd.IsSupported)
-            {
-                testPermuteOp<float,  Vector128<float >>(name, (x, y) => Simd.Insert(x, 1, (float )2), (i, x, y) => (float )(i != 1 ? x[i] : 2));
-                testPermuteOp<double, Vector128<double>>(name, (x, y) => Simd.Insert(x, 1, (double)2), (i, x, y) => (double)(i != 1 ? x[i] : 2));
-                testPermuteOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Insert(x, 1, (sbyte )2), (i, x, y) => (sbyte )(i != 1 ? x[i] : 2));
-                testPermuteOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.Insert(x, 1, (byte  )2), (i, x, y) => (byte  )(i != 1 ? x[i] : 2));
-                testPermuteOp<short,  Vector128<short >>(name, (x, y) => Simd.Insert(x, 1, (short )2), (i, x, y) => (short )(i != 1 ? x[i] : 2));
-                testPermuteOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.Insert(x, 1, (ushort)2), (i, x, y) => (ushort)(i != 1 ? x[i] : 2));
-                testPermuteOp<int,    Vector128<int   >>(name, (x, y) => Simd.Insert(x, 1, (int   )2), (i, x, y) => (int   )(i != 1 ? x[i] : 2));
-                testPermuteOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.Insert(x, 1, (uint  )2), (i, x, y) => (uint  )(i != 1 ? x[i] : 2));
-                testPermuteOp<long,   Vector128<long  >>(name, (x, y) => Simd.Insert(x, 1, (long  )2), (i, x, y) => (long  )(i != 1 ? x[i] : 2));
-                testPermuteOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.Insert(x, 1, (ulong )2), (i, x, y) => (ulong )(i != 1 ? x[i] : 2));
-                testPermuteOp<float,  Vector64< float >>(name, (x, y) => Simd.Insert(x, 1, (float )2), (i, x, y) => (float )(i != 1 ? x[i] : 2));
-                testPermuteOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Insert(x, 1, (sbyte )2), (i, x, y) => (sbyte )(i != 1 ? x[i] : 2));
-                testPermuteOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.Insert(x, 1, (byte  )2), (i, x, y) => (byte  )(i != 1 ? x[i] : 2));
-                testPermuteOp<short,  Vector64< short >>(name, (x, y) => Simd.Insert(x, 1, (short )2), (i, x, y) => (short )(i != 1 ? x[i] : 2));
-                testPermuteOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.Insert(x, 1, (ushort)2), (i, x, y) => (ushort)(i != 1 ? x[i] : 2));
-                testPermuteOp<int,    Vector64< int   >>(name, (x, y) => Simd.Insert(x, 1, (int   )2), (i, x, y) => (int   )(i != 1 ? x[i] : 2));
-                testPermuteOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.Insert(x, 1, (uint  )2), (i, x, y) => (uint  )(i != 1 ? x[i] : 2));
-
-                testPermuteOp<float,  Vector128<float >>(name, (x, y) => Simd.Insert(x, 3, Simd.Extract(y, 1)), (i, x, y) => (float )(i != 3 ? x[i] : y[1]));
-                testPermuteOp<double, Vector128<double>>(name, (x, y) => Simd.Insert(x, 0, Simd.Extract(y, 1)), (i, x, y) => (double)(i != 0 ? x[i] : y[1]));
-                testPermuteOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Insert(x, 9, Simd.Extract(y, 1)), (i, x, y) => (sbyte )(i != 9 ? x[i] : y[1]));
-                testPermuteOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.Insert(x, 9, Simd.Extract(y, 1)), (i, x, y) => (byte  )(i != 9 ? x[i] : y[1]));
-                testPermuteOp<short,  Vector128<short >>(name, (x, y) => Simd.Insert(x, 5, Simd.Extract(y, 1)), (i, x, y) => (short )(i != 5 ? x[i] : y[1]));
-                testPermuteOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.Insert(x, 5, Simd.Extract(y, 1)), (i, x, y) => (ushort)(i != 5 ? x[i] : y[1]));
-                testPermuteOp<int,    Vector128<int   >>(name, (x, y) => Simd.Insert(x, 2, Simd.Extract(y, 1)), (i, x, y) => (int   )(i != 2 ? x[i] : y[1]));
-                testPermuteOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.Insert(x, 2, Simd.Extract(y, 1)), (i, x, y) => (uint  )(i != 2 ? x[i] : y[1]));
-                testPermuteOp<long,   Vector128<long  >>(name, (x, y) => Simd.Insert(x, 0, Simd.Extract(y, 1)), (i, x, y) => (long  )(i != 0 ? x[i] : y[1]));
-                testPermuteOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.Insert(x, 0, Simd.Extract(y, 1)), (i, x, y) => (ulong )(i != 0 ? x[i] : y[1]));
-                testPermuteOp<float,  Vector64< float >>(name, (x, y) => Simd.Insert(x, 0, Simd.Extract(y, 1)), (i, x, y) => (float )(i != 0 ? x[i] : y[1]));
-                testPermuteOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Insert(x, 7, Simd.Extract(y, 1)), (i, x, y) => (sbyte )(i != 7 ? x[i] : y[1]));
-                testPermuteOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.Insert(x, 7, Simd.Extract(y, 1)), (i, x, y) => (byte  )(i != 7 ? x[i] : y[1]));
-                testPermuteOp<short,  Vector64< short >>(name, (x, y) => Simd.Insert(x, 2, Simd.Extract(y, 1)), (i, x, y) => (short )(i != 2 ? x[i] : y[1]));
-                testPermuteOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.Insert(x, 2, Simd.Extract(y, 1)), (i, x, y) => (ushort)(i != 2 ? x[i] : y[1]));
-                testPermuteOp<int,    Vector64< int   >>(name, (x, y) => Simd.Insert(x, 0, Simd.Extract(y, 1)), (i, x, y) => (int   )(i != 0 ? x[i] : y[1]));
-                testPermuteOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.Insert(x, 0, Simd.Extract(y, 1)), (i, x, y) => (uint  )(i != 0 ? x[i] : y[1]));
-
-                testThrowsArgumentOutOfRangeException<float,  Vector128<float >, Vector128<float >>(name, (x, y) => Simd.Insert(x, 4, (float )1));
-                testThrowsArgumentOutOfRangeException<double, Vector128<double>, Vector128<double>>(name, (x, y) => Simd.Insert(x, 2, (double)1));
-                testThrowsArgumentOutOfRangeException<sbyte,  Vector128<sbyte >, Vector128<sbyte >>(name, (x, y) => Simd.Insert(x,16, (sbyte )1));
-                testThrowsArgumentOutOfRangeException<byte,   Vector128<byte  >, Vector128<byte  >>(name, (x, y) => Simd.Insert(x,16, (byte  )1));
-                testThrowsArgumentOutOfRangeException<short,  Vector128<short >, Vector128<short >>(name, (x, y) => Simd.Insert(x, 8, (short )1));
-                testThrowsArgumentOutOfRangeException<ushort, Vector128<ushort>, Vector128<ushort>>(name, (x, y) => Simd.Insert(x, 8, (ushort)1));
-                testThrowsArgumentOutOfRangeException<int,    Vector128<int   >, Vector128<int   >>(name, (x, y) => Simd.Insert(x, 4, (int   )1));
-                testThrowsArgumentOutOfRangeException<uint,   Vector128<uint  >, Vector128<uint  >>(name, (x, y) => Simd.Insert(x, 4, (uint  )1));
-                testThrowsArgumentOutOfRangeException<long,   Vector128<long  >, Vector128<long  >>(name, (x, y) => Simd.Insert(x, 2, (long  )1));
-                testThrowsArgumentOutOfRangeException<ulong,  Vector128<ulong >, Vector128<ulong >>(name, (x, y) => Simd.Insert(x, 2, (ulong )1));
-                testThrowsArgumentOutOfRangeException<float,  Vector64< float >, Vector64< float >>(name, (x, y) => Simd.Insert(x, 2, (float )1));
-                testThrowsArgumentOutOfRangeException<sbyte,  Vector64< sbyte >, Vector64< sbyte >>(name, (x, y) => Simd.Insert(x, 8, (sbyte )1));
-                testThrowsArgumentOutOfRangeException<byte,   Vector64< byte  >, Vector64< byte  >>(name, (x, y) => Simd.Insert(x, 8, (byte  )1));
-                testThrowsArgumentOutOfRangeException<short,  Vector64< short >, Vector64< short >>(name, (x, y) => Simd.Insert(x, 4, (short )1));
-                testThrowsArgumentOutOfRangeException<ushort, Vector64< ushort>, Vector64< ushort>>(name, (x, y) => Simd.Insert(x, 4, (ushort)1));
-                testThrowsArgumentOutOfRangeException<int,    Vector64< int   >, Vector64< int   >>(name, (x, y) => Simd.Insert(x, 2, (int   )1));
-                testThrowsArgumentOutOfRangeException<uint,   Vector64< uint  >, Vector64< uint  >>(name, (x, y) => Simd.Insert(x, 2, (uint  )1));
-
-                testThrowsTypeNotSupported<Vector128<bool >>(name, (x, y) => Simd.Insert(x, 1,      true));
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.Insert(x, 1, ( long )5));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.Insert(x, 1, ( ulong)5));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.Insert(x, 1, (double)5));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Insert(x, 1, (float )1));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.Insert(x, 1, (double)1));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.Insert(x, 1, (sbyte )1));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.Insert(x, 1, (byte  )1));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.Insert(x, 1, (short )1));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.Insert(x, 1, (ushort)1));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.Insert(x, 1, (int   )1));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.Insert(x, 1, (uint  )1));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.Insert(x, 1, (long  )1));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.Insert(x, 1, (ulong )1));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Insert(x, 1, (float )1));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Insert(x, 1, (double)1));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.Insert(x, 1, (sbyte )1));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.Insert(x, 1, (byte  )1));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.Insert(x, 1, (short )1));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.Insert(x, 1, (ushort)1));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.Insert(x, 1, (int   )1));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.Insert(x, 1, (uint  )1));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.Insert(x, 1, (long  )1));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.Insert(x, 1, (ulong )1));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestLeadingSignCount()
-        {
-            String name = "LeadingSignCount";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.LeadingSignCount(x), (x, y) => leadingSign(x));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.LeadingSignCount(x), (x, y) => leadingSign(x));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.LeadingSignCount(x), (x, y) => leadingSign(x));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.LeadingSignCount(x), (x, y) => leadingSign(x));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.LeadingSignCount(x), (x, y) => leadingSign(x));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.LeadingSignCount(x), (x, y) => leadingSign(x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.LeadingSignCount(x));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.LeadingSignCount(x));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.LeadingSignCount(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.LeadingSignCount(x));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.LeadingSignCount(x));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.LeadingSignCount(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestLeadingZeroCount()
-        {
-            String name = "LeadingZeroCount";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.LeadingZeroCount(x), (x, y) => leadingZero(x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.LeadingZeroCount(x));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.LeadingZeroCount(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestMax()
-        {
-            String name = "Max";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Max(x, y), (x, y) =>         ((x > y) ? x : y));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Max(x, y), (x, y) =>         ((x > y) ? x : y));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Max(x, y), (x, y) => (sbyte) ((x > y) ? x : y));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.Max(x, y), (x, y) => (byte)  ((x > y) ? x : y));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.Max(x, y), (x, y) => (short) ((x > y) ? x : y));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.Max(x, y), (x, y) => (ushort)((x > y) ? x : y));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.Max(x, y), (x, y) =>         ((x > y) ? x : y));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.Max(x, y), (x, y) =>         ((x > y) ? x : y));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Max(x, y), (x, y) =>         ((x > y) ? x : y));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Max(x, y), (x, y) => (sbyte) ((x > y) ? x : y));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.Max(x, y), (x, y) => (byte)  ((x > y) ? x : y));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.Max(x, y), (x, y) => (short) ((x > y) ? x : y));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.Max(x, y), (x, y) => (ushort)((x > y) ? x : y));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.Max(x, y), (x, y) =>         ((x > y) ? x : y));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.Max(x, y), (x, y) =>         ((x > y) ? x : y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.Max(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.Max(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestMin()
-        {
-            String name = "Min";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Min(x, y), (x, y) =>         ((x < y) ? x : y));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Min(x, y), (x, y) =>         ((x < y) ? x : y));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Min(x, y), (x, y) => (sbyte) ((x < y) ? x : y));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.Min(x, y), (x, y) => (byte)  ((x < y) ? x : y));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.Min(x, y), (x, y) => (short) ((x < y) ? x : y));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.Min(x, y), (x, y) => (ushort)((x < y) ? x : y));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.Min(x, y), (x, y) =>         ((x < y) ? x : y));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.Min(x, y), (x, y) =>         ((x < y) ? x : y));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Min(x, y), (x, y) =>         ((x < y) ? x : y));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Min(x, y), (x, y) => (sbyte) ((x < y) ? x : y));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.Min(x, y), (x, y) => (byte)  ((x < y) ? x : y));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.Min(x, y), (x, y) => (short) ((x < y) ? x : y));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.Min(x, y), (x, y) => (ushort)((x < y) ? x : y));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.Min(x, y), (x, y) =>         ((x < y) ? x : y));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.Min(x, y), (x, y) =>         ((x < y) ? x : y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.Min(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.Min(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestMultiply()
-        {
-            String name = "Multiply";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Multiply(x, y), (x, y) =>         (x * y));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Multiply(x, y), (x, y) =>         (x * y));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Multiply(x, y), (x, y) => (sbyte) (x * y));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.Multiply(x, y), (x, y) => (byte)  (x * y));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.Multiply(x, y), (x, y) => (short) (x * y));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.Multiply(x, y), (x, y) => (ushort)(x * y));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.Multiply(x, y), (x, y) =>         (x * y));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.Multiply(x, y), (x, y) =>         (x * y));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Multiply(x, y), (x, y) =>         (x * y));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Multiply(x, y), (x, y) => (sbyte) (x * y));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.Multiply(x, y), (x, y) => (byte)  (x * y));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.Multiply(x, y), (x, y) => (short) (x * y));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.Multiply(x, y), (x, y) => (ushort)(x * y));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.Multiply(x, y), (x, y) =>         (x * y));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.Multiply(x, y), (x, y) =>         (x * y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.Multiply(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.Multiply(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestNegate()
-        {
-            String name = "Negate";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Negate(x), (x, y) =>         (-x));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Negate(x), (x, y) =>         (-x));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Negate(x), (x, y) => (sbyte) (-x));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.Negate(x), (x, y) => (short) (-x));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.Negate(x), (x, y) =>         (-x));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.Negate(x), (x, y) =>         (-x));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Negate(x), (x, y) =>         (-x));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Negate(x), (x, y) => (sbyte) (-x));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.Negate(x), (x, y) => (short) (-x));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.Negate(x), (x, y) =>         (-x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Negate(x));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.Negate(x));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.Negate(x));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.Negate(x));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Negate(x));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Negate(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.Negate(x));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.Negate(x));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.Negate(x));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.Negate(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestNot()
-        {
-            String name = "Not";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Not(x), (x, y) => bitsToFloat (~bits(x)));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Not(x), (x, y) => bitsToDouble(~bits(x)));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Not(x), (x, y) => (sbyte)     (~     x ));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.Not(x), (x, y) => (byte)      (~     x ));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.Not(x), (x, y) => (short)     (~     x ));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.Not(x), (x, y) => (ushort)    (~     x ));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.Not(x), (x, y) =>             (~     x ));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.Not(x), (x, y) =>             (~     x ));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.Not(x), (x, y) =>             (~     x ));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.Not(x), (x, y) =>             (~     x ));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Not(x), (x, y) => bitsToFloat (~bits(x)));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Not(x), (x, y) => (sbyte)     (~     x ));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.Not(x), (x, y) => (byte)      (~     x ));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.Not(x), (x, y) => (short)     (~     x ));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.Not(x), (x, y) => (ushort)    (~     x ));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.Not(x), (x, y) =>             (~     x ));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.Not(x), (x, y) =>             (~     x ));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.Not(x));
-
-                testThrowsTypeNotSupported<Vector64< long  >>(name, (x, y) => Simd.Not(x));
-                testThrowsTypeNotSupported<Vector64< ulong >>(name, (x, y) => Simd.Not(x));
-                testThrowsTypeNotSupported<Vector64< double>>(name, (x, y) => Simd.Not(x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.Not(x));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.Not(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestOr()
-        {
-            String name = "Or";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Or(x, y), (x, y) => bitsToFloat (bits(x) | bits(y)));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Or(x, y), (x, y) => bitsToDouble(bits(x) | bits(y)));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Or(x, y), (x, y) => (sbyte)     (     x  |      y ));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.Or(x, y), (x, y) => (byte)      (     x  |      y ));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.Or(x, y), (x, y) => (short)     (     x  |      y ));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.Or(x, y), (x, y) => (ushort)    (     x  |      y ));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.Or(x, y), (x, y) =>             (     x  |      y ));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.Or(x, y), (x, y) =>             (     x  |      y ));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.Or(x, y), (x, y) =>             (     x  |      y ));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.Or(x, y), (x, y) =>             (     x  |      y ));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Or(x, y), (x, y) => bitsToFloat (bits(x) | bits(y)));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Or(x, y), (x, y) => (sbyte)     (     x  |      y ));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.Or(x, y), (x, y) => (byte)      (     x  |      y ));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.Or(x, y), (x, y) => (short)     (     x  |      y ));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.Or(x, y), (x, y) => (ushort)    (     x  |      y ));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.Or(x, y), (x, y) =>             (     x  |      y ));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.Or(x, y), (x, y) =>             (     x  |      y ));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.Or(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long  >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsTypeNotSupported<Vector64< double>>(name, (x, y) => Simd.Or(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.Or(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.Or(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestOrNot()
-        {
-            String name = "OrNot";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.OrNot(x, y), (x, y) => bitsToFloat (bits(x) | ~bits(y)));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.OrNot(x, y), (x, y) => bitsToDouble(bits(x) | ~bits(y)));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.OrNot(x, y), (x, y) => (sbyte)     (     x  | ~     y ));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.OrNot(x, y), (x, y) => (byte)      (     x  | ~     y ));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.OrNot(x, y), (x, y) => (short)     (     x  | ~     y ));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.OrNot(x, y), (x, y) => (ushort)    (     x  | ~     y ));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.OrNot(x, y), (x, y) =>             (     x  | ~     y ));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.OrNot(x, y), (x, y) =>             (     x  | ~     y ));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.OrNot(x, y), (x, y) =>             (     x  | ~     y ));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.OrNot(x, y), (x, y) =>             (     x  | ~     y ));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.OrNot(x, y), (x, y) => bitsToFloat (bits(x) | ~bits(y)));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.OrNot(x, y), (x, y) => (sbyte)     (     x  | ~     y ));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.OrNot(x, y), (x, y) => (byte)      (     x  | ~     y ));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.OrNot(x, y), (x, y) => (short)     (     x  | ~     y ));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.OrNot(x, y), (x, y) => (ushort)    (     x  | ~     y ));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.OrNot(x, y), (x, y) =>             (     x  | ~     y ));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.OrNot(x, y), (x, y) =>             (     x  | ~     y ));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.OrNot(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long  >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsTypeNotSupported<Vector64< double>>(name, (x, y) => Simd.OrNot(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.OrNot(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.OrNot(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestPopCount()
-        {
-            String name = "PopCount";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.PopCount(x), (x, y) => popCount(x));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.PopCount(x), (x, y) => popCount(x));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.PopCount(x), (x, y) => popCount(x));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.PopCount(x), (x, y) => popCount(x));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.PopCount(x));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.PopCount(x));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.PopCount(x));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.PopCount(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestSetAllVector()
-        {
-            String name = "SetAllVector";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.SetAllVector128((float )4), (x, y) => (float )4);
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.SetAllVector128((double)4), (x, y) => (double)4);
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.SetAllVector128((sbyte )4), (x, y) => (sbyte )4);
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.SetAllVector128((byte  )4), (x, y) => (byte  )4);
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.SetAllVector128((short )4), (x, y) => (short )4);
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.SetAllVector128((ushort)4), (x, y) => (ushort)4);
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.SetAllVector128((int   )4), (x, y) => (int   )4);
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.SetAllVector128((uint  )4), (x, y) => (uint  )4);
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.SetAllVector128((long  )4), (x, y) => (long  )4);
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.SetAllVector128((ulong )4), (x, y) => (ulong )4);
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.SetAllVector64( (float )4), (x, y) => (float )4);
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.SetAllVector64( (sbyte )4), (x, y) => (sbyte )4);
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.SetAllVector64( (byte  )4), (x, y) => (byte  )4);
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.SetAllVector64( (short )4), (x, y) => (short )4);
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.SetAllVector64( (ushort)4), (x, y) => (ushort)4);
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.SetAllVector64( (int   )4), (x, y) => (int   )4);
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.SetAllVector64( (uint  )4), (x, y) => (uint  )4);
-
-                //testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.SetAllVector128(Simd.SetAllVector128((long  )5)));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.SetAllVector64((long  )6));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.SetAllVector64((ulong )6));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.SetAllVector64((double)6));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.SetAllVector64((float )7));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.SetAllVector64((sbyte )7));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.SetAllVector64((byte  )7));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.SetAllVector64((short )7));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.SetAllVector64((ushort)7));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.SetAllVector64((int   )7));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.SetAllVector64((uint  )7));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.SetAllVector64((long  )7));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.SetAllVector64((ulong )7));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.SetAllVector64((double)7));
-
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.SetAllVector128((float )8));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.SetAllVector128((double)8));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.SetAllVector128((sbyte )8));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.SetAllVector128((byte  )8));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.SetAllVector128((short )8));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.SetAllVector128((ushort)8));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.SetAllVector128((int   )8));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.SetAllVector128((uint  )8));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.SetAllVector128((long  )8));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.SetAllVector128((ulong )8));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestSqrt()
-        {
-            String name = "Sqrt";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Sqrt(x), (x, y) =>         ((float) Math.Sqrt(x)));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Sqrt(x), (x, y) =>         (        Math.Sqrt(x)));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Sqrt(x), (x, y) =>         ((float) Math.Sqrt(x)));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Sqrt(x));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Sqrt(x));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Sqrt(x));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestSubtract()
-        {
-            String name = "Subtract";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Subtract(x, y), (x, y) =>         (x - y));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Subtract(x, y), (x, y) =>         (x - y));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Subtract(x, y), (x, y) => (sbyte) (x - y));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.Subtract(x, y), (x, y) => (byte)  (x - y));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.Subtract(x, y), (x, y) => (short) (x - y));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.Subtract(x, y), (x, y) => (ushort)(x - y));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.Subtract(x, y), (x, y) =>         (x - y));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.Subtract(x, y), (x, y) =>         (x - y));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.Subtract(x, y), (x, y) =>         (x - y));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.Subtract(x, y), (x, y) =>         (x - y));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Subtract(x, y), (x, y) =>         (x - y));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Subtract(x, y), (x, y) => (sbyte) (x - y));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.Subtract(x, y), (x, y) => (byte)  (x - y));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.Subtract(x, y), (x, y) => (short) (x - y));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.Subtract(x, y), (x, y) => (ushort)(x - y));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.Subtract(x, y), (x, y) =>         (x - y));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.Subtract(x, y), (x, y) =>         (x - y));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.Subtract(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong>>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsTypeNotSupported<Vector64<double>>(name, (x, y) => Simd.Subtract(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.Subtract(x, y));
-
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.Subtract(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.Subtract(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void TestXor()
-        {
-            String name = "Xor";
-
-            if (Simd.IsSupported)
-            {
-                testBinOp<float,  Vector128<float >>(name, (x, y) => Simd.Xor(x, y), (x, y) => bitsToFloat (bits(x) ^ bits(y)));
-                testBinOp<double, Vector128<double>>(name, (x, y) => Simd.Xor(x, y), (x, y) => bitsToDouble(bits(x) ^ bits(y)));
-                testBinOp<sbyte,  Vector128<sbyte >>(name, (x, y) => Simd.Xor(x, y), (x, y) => (sbyte)     (     x  ^      y ));
-                testBinOp<byte,   Vector128<byte  >>(name, (x, y) => Simd.Xor(x, y), (x, y) => (byte)      (     x  ^      y ));
-                testBinOp<short,  Vector128<short >>(name, (x, y) => Simd.Xor(x, y), (x, y) => (short)     (     x  ^      y ));
-                testBinOp<ushort, Vector128<ushort>>(name, (x, y) => Simd.Xor(x, y), (x, y) => (ushort)    (     x  ^      y ));
-                testBinOp<int,    Vector128<int   >>(name, (x, y) => Simd.Xor(x, y), (x, y) =>             (     x  ^      y ));
-                testBinOp<uint,   Vector128<uint  >>(name, (x, y) => Simd.Xor(x, y), (x, y) =>             (     x  ^      y ));
-                testBinOp<long,   Vector128<long  >>(name, (x, y) => Simd.Xor(x, y), (x, y) =>             (     x  ^      y ));
-                testBinOp<ulong,  Vector128<ulong >>(name, (x, y) => Simd.Xor(x, y), (x, y) =>             (     x  ^      y ));
-                testBinOp<float,  Vector64< float >>(name, (x, y) => Simd.Xor(x, y), (x, y) => bitsToFloat (bits(x) ^ bits(y)));
-                testBinOp<sbyte,  Vector64< sbyte >>(name, (x, y) => Simd.Xor(x, y), (x, y) => (sbyte)     (     x  ^      y ));
-                testBinOp<byte,   Vector64< byte  >>(name, (x, y) => Simd.Xor(x, y), (x, y) => (byte)      (     x  ^      y ));
-                testBinOp<short,  Vector64< short >>(name, (x, y) => Simd.Xor(x, y), (x, y) => (short)     (     x  ^      y ));
-                testBinOp<ushort, Vector64< ushort>>(name, (x, y) => Simd.Xor(x, y), (x, y) => (ushort)    (     x  ^      y ));
-                testBinOp<int,    Vector64< int   >>(name, (x, y) => Simd.Xor(x, y), (x, y) =>             (     x  ^      y ));
-                testBinOp<uint,   Vector64< uint  >>(name, (x, y) => Simd.Xor(x, y), (x, y) =>             (     x  ^      y ));
-
-                testThrowsTypeNotSupported<Vector128<Vector128<long> >>(name, (x, y) => Simd.Xor(x, y));
-
-                testThrowsTypeNotSupported<Vector64< long  >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsTypeNotSupported<Vector64< ulong >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsTypeNotSupported<Vector64< double>>(name, (x, y) => Simd.Xor(x, y));
-            }
-            else
-            {
-                testThrowsPlatformNotSupported<Vector64< float >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector64< double>>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector64< sbyte >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector64< byte  >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector64< short >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector64< ushort>>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector64< int   >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector64< uint  >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector64< long  >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector64< ulong >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector128<float >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector128<double>>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector128<sbyte >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector128<byte  >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector128<short >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector128<ushort>>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector128<int   >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector128<uint  >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector128<long  >>(name, (x, y) => Simd.Xor(x, y));
-                testThrowsPlatformNotSupported<Vector128<ulong >>(name, (x, y) => Simd.Xor(x, y));
-            }
-
-            Console.WriteLine($"Test{name} passed");
-        }
-
-        static void initializeDataSetDefault()
-        {
-            DataSet<float,  Vector64< float >>.setData(new float[]  { 1, -5 },                                                    new float[] { 22, -1 });
-            DataSet<sbyte,  Vector64< sbyte >>.setData(new sbyte[]  { 1, -5, 100, 0, 7, 8, -2, -9 },                              new sbyte[] { 22, -1, -50, 0, 7, 5, 3, -33 });
-            DataSet<byte,   Vector64< byte  >>.setData(new byte[]   { 1,  5, 100, 0, 7, 8,  2,  9 },                              new byte[]  { 22,  1,  50, 0, 7, 5, 3,  33 });
-            DataSet<short,  Vector64< short >>.setData(new short[]  { 1, -5, 100, 0 },                                            new short[] { 22, -1, -50, 0 });
-            DataSet<ushort, Vector64< ushort>>.setData(new ushort[] { 1,  5, 100, 0 },                                            new ushort[]{ 22,  1,  50, 0 });
-            DataSet<int,    Vector64< int   >>.setData(new int[]    { 1, -5 },                                                    new int[]   { 22, -1 });
-            DataSet<uint,   Vector64< uint  >>.setData(new uint[]   { 1,  5 },                                                    new uint[]  { 22,  1 });
-            DataSet<float,  Vector128<float >>.setData(new float[]  { 1, -5, 100, 0 },                                            new float[] { 22, -1, -50, 0 });
-            DataSet<double, Vector128<double>>.setData(new double[] { 1, -5 },                                                    new double[]{ 22, -1 });
-            DataSet<sbyte,  Vector128<sbyte >>.setData(new sbyte[]  { 1, -5, 100, 0, 7, 8, -2, -9, 1, -5, 100, 0, 7, 8, -2, -9 }, new sbyte[] { 22, -1, -50, 0, 7, 5, 3, -33, -17, 4, 100, 120, 27, 6, -2, -6 });
-            DataSet<byte,   Vector128<byte  >>.setData(new byte[]   { 1,  5, 100, 0, 7, 8,  2,  9, 1,  5, 100, 0, 7, 8,  2,  9 }, new byte[]  { 22,  1,  50, 0, 7, 5, 3,  33,  17, 4, 100, 120, 27, 6,  2,  6 });
-            DataSet<short,  Vector128<short >>.setData(new short[]  { 1, -5, 100, 0, 7, 8, -2, -9 },                              new short[] { 22, -1, -50, 0, 7, 5, 3, -33 });
-            DataSet<ushort, Vector128<ushort>>.setData(new ushort[] { 1,  5, 100, 0, 7, 8,  2,  9 },                              new ushort[]{ 22,  1,  50, 0, 7, 5, 3,  33 });
-            DataSet<int,    Vector128<int   >>.setData(new int[]    { 1, -5, 100, 0 },                                            new int[]   { 22, -1, -50, 0 });
-            DataSet<uint,   Vector128<uint  >>.setData(new uint[]   { 1,  5, 100, 0 },                                            new uint[]  { 22,  1,  50, 0 });
-            DataSet<long,   Vector128<long  >>.setData(new long[]   { 1, -5 },                                                    new long[]  { 22, -1 });
-            DataSet<ulong,  Vector128<ulong >>.setData(new ulong[]  { 1,  5 },                                                    new ulong[] { 22,  1 });
-
-            Console.WriteLine("Using default data set");
-        }
-
-        static void initializeDataSetCompare()
-        {
-            DataSet<float,  Vector64< float >>.setData(new float[]  { 1, 0 },                                                    new float[] { 1, 17 });
-            DataSet<sbyte,  Vector64< sbyte >>.setData(new sbyte[]  { 1, 0, 100, 0, 7, 8, -2, -9 },                              new sbyte[] { 1, 17, -50, 0, 7, 5, 3, -33 });
-            DataSet<byte,   Vector64< byte  >>.setData(new byte[]   { 1, 0, 100, 0, 7, 8,  2,  9 },                              new byte[]  { 1, 17,  50, 0, 7, 5, 3,  33 });
-            DataSet<short,  Vector64< short >>.setData(new short[]  { 1, 0, 100, 0 },                                            new short[] { 1, 17, -50, 0 });
-            DataSet<ushort, Vector64< ushort>>.setData(new ushort[] { 1, 0, 100, 0 },                                            new ushort[]{ 1, 17,  50, 0 });
-            DataSet<int,    Vector64< int   >>.setData(new int[]    { 1, 0 },                                                    new int[]   { 1, 17 });
-            DataSet<uint,   Vector64< uint  >>.setData(new uint[]   { 1, 0 },                                                    new uint[]  { 1, 17 });
-            DataSet<float,  Vector128<float >>.setData(new float[]  { 1, 0, 100, 0 },                                            new float[] { 1, 17, -50, 0 });
-            DataSet<double, Vector128<double>>.setData(new double[] { 1, 0 },                                                    new double[]{ 1, 17 });
-            DataSet<sbyte,  Vector128<sbyte >>.setData(new sbyte[]  { 1, 0, 100, 0, 7, 8, -2, -9, 1, -5, 100, 0, 7, 8, -2, -9 }, new sbyte[] { 1, 17, -50, 0, 7, 5, 3, -33, -17, 4, 100, 120, 27, 6, -2, -6 });
-            DataSet<byte,   Vector128<byte  >>.setData(new byte[]   { 1, 0, 100, 0, 7, 8,  2,  9, 1,  5, 100, 0, 7, 8,  2,  9 }, new byte[]  { 1, 17,  50, 0, 7, 5, 3,  33,  17, 4, 100, 120, 27, 6,  2,  6 });
-            DataSet<short,  Vector128<short >>.setData(new short[]  { 1, 0, 100, 0, 7, 8, -2, -9 },                              new short[] { 1, 17, -50, 0, 7, 5, 3, -33 });
-            DataSet<ushort, Vector128<ushort>>.setData(new ushort[] { 1, 0, 100, 0, 7, 8,  2,  9 },                              new ushort[]{ 1, 17,  50, 0, 7, 5, 3,  33 });
-            DataSet<int,    Vector128<int   >>.setData(new int[]    { 1, 0, 100, 0 },                                            new int[]   { 1, 17, -50, 0 });
-            DataSet<uint,   Vector128<uint  >>.setData(new uint[]   { 1, 0, 100, 0 },                                            new uint[]  { 1, 17,  50, 0 });
-            DataSet<long,   Vector128<long  >>.setData(new long[]   { 1, 0 },                                                    new long[]  { 1, 17 });
-            DataSet<ulong,  Vector128<ulong >>.setData(new ulong[]  { 1, 0 },                                                    new ulong[] { 1, 17 });
-
-            Console.WriteLine("Using compare data set");
-        }
-
-        static void ExecuteAllTests()
-        {
-            TestAbs();
-            TestAdd();
-            TestAnd();
-            TestAndNot();
-            TestBitwiseSelect();
-            TestCompareEqual();
-            TestCompareEqualZero();
-            TestCompareGreaterThan();
-            TestCompareGreaterThanZero();
-            TestCompareGreaterThanOrEqual();
-            TestCompareGreaterThanOrEqualZero();
-            TestCompareLessThanZero();
-            TestCompareLessThanOrEqualZero();
-            TestCompareTest();
-            TestDivide();
-            TestExtract();
-            TestInsert();
-            TestLeadingSignCount();
-            TestLeadingZeroCount();
-            TestMax();
-            TestMin();
-            TestMultiply();
-            TestNegate();
-            TestNot();
-            TestOr();
-            TestOrNot();
-            TestPopCount();
-            TestSetAllVector();
-            TestSqrt();
-            TestSubtract();
-            TestXor();
-        }
-
-        static int Main(string[] args)
-        {
-            Console.WriteLine($"System.Runtime.Intrinsics.Arm.Arm64.Simd.IsSupported = {Simd.IsSupported}");
-
-            // Reflection call
-            var issupported = "get_IsSupported";
-            bool reflectedIsSupported = Convert.ToBoolean(typeof(Simd).GetMethod(issupported).Invoke(null, null));
-
-            Debug.Assert(reflectedIsSupported == Simd.IsSupported, "Reflection result does not match");
-
-            initializeDataSetDefault();
-
-            ExecuteAllTests();
-
-            initializeDataSetCompare();
-
-            ExecuteAllTests();
-
-            return 100;
-        }
-    }
-}

diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Simd.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Simd.csproj
deleted file mode 100644 (file)
index 202a61a..0000000
--- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm64/Simd.csproj
+++ /dev/null
@@ -1,13 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-  <PropertyGroup>
-    <DebugType>None</DebugType>
-    <Optimize>True</Optimize>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="Simd.cs" />
-  </ItemGroup>
-</Project>

diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
index 3745146df8585340b9b3b481172077d5a24b1ce5..629646df9ea3e51b967b2423b4b6d8c83aeb2d90 100644 (file)
--- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
+++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
@@ -1340,17 +1340,17 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\X86\Ssse3.PlatformNotSupported.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(FeatureHardwareIntrinsics)' == 'true' AND '$(Platform)' == 'arm64'">
-    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Arm64\Aes.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Arm64\Base.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Arm64\Sha1.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Arm64\Sha256.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Arm64\Simd.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\AdvSimd.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Aes.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\ArmBase.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Sha1.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Sha256.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(FeatureHardwareIntrinsics)' != 'true' OR '$(Platform)' != 'arm64'">
-    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Arm64\Aes.PlatformNotSupported.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Arm64\Base.PlatformNotSupported.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Arm64\Sha1.PlatformNotSupported.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Arm64\Sha256.PlatformNotSupported.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Arm64\Simd.PlatformNotSupported.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\AdvSimd.PlatformNotSupported.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Aes.PlatformNotSupported.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\ArmBase.PlatformNotSupported.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Sha1.PlatformNotSupported.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Arm\Sha256.PlatformNotSupported.cs" />
   </ItemGroup>
 </Project>

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs
new file mode 100644 (file)
index 0000000..1feea53
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs
@@ -0,0 +1,377 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.Arm
+{
+    /// <summary>
+    /// This class provides access to the ARM AdvSIMD hardware instructions via intrinsics
+    /// </summary>
+    [CLSCompliant(false)]
+    public abstract class AdvSimd : ArmBase
+    {
+        internal AdvSimd() { }
+
+        public static new bool IsSupported { [Intrinsic] get { return false; } }
+
+        public new abstract class Arm64 : ArmBase.Arm64
+        {
+            internal Arm64() { }
+
+            public static new bool IsSupported { [Intrinsic] get { return false; } }
+
+            /// <summary>
+            /// float64x2_t vabsq_f64 (float64x2_t a)
+            ///   A64: FABS Vd.2D, Vn.2D
+            /// </summary>
+            public static Vector128<double> Abs(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int64x2_t vabsq_s64 (int64x2_t a)
+            ///   A64: ABS Vd.2D, Vn.2D
+            /// </summary>
+            public static Vector128<ulong> Abs(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+            // /// <summary>
+            // /// int64x1_t vabs_s64 (int64x1_t a)
+            // ///   A64: ABS Dd, Dn
+            // /// </summary>
+            // public static Vector64<ulong> AbsScalar(Vector64<long> value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// float64x2_t vaddq_f64 (float64x2_t a, float64x2_t b)
+            ///   A64: FADD Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<double> Add(Vector128<double> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        }
+
+        /// <summary>
+        /// int8x8_t vabs_s8 (int8x8_t a)
+        ///   A32: VABS.S8 Dd, Dm
+        ///   A64: ABS Vd.8B, Vn.8B
+        /// </summary>
+        public static Vector64<byte> Abs(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vabs_s16 (int16x4_t a)
+        ///   A32: VABS.S16 Dd, Dm
+        ///   A64: ABS Vd.4H, Vn.4H
+        /// </summary>
+        public static Vector64<ushort> Abs(Vector64<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vabs_s32 (int32x2_t a)
+        ///   A32: VABS.S32 Dd, Dm
+        ///   A64: ABS Vd.2S, Vn.2S
+        /// </summary>
+        public static Vector64<uint> Abs(Vector64<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x2_t vabs_f32 (float32x2_t a)
+        ///   A32: VABS.F32 Dd, Dm
+        ///   A64: FABS Vd.2S, Vn.2S
+        /// </summary>
+        public static Vector64<float> Abs(Vector64<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vabsq_s8 (int8x16_t a)
+        ///   A32: VABS.S8 Qd, Qm
+        ///   A64: ABS Vd.16B, Vn.16B
+        /// </summary>
+        public static Vector128<byte> Abs(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vabsq_s16 (int16x8_t a)
+        ///   A32: VABS.S16 Qd, Qm
+        ///   A64: ABS Vd.8H, Vn.8H
+        /// </summary>
+        public static Vector128<ushort> Abs(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vabsq_s32 (int32x4_t a)
+        ///   A32: VABS.S32 Qd, Qm
+        ///   A64: ABS Vd.4S, Vn.4S
+        /// </summary>
+        public static Vector128<uint> Abs(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vabsq_f32 (float32x4_t a)
+        ///   A32: VABS.F32 Qd, Qm
+        ///   A64: FABS Vd.4S, Vn.4S
+        /// </summary>
+        public static Vector128<float> Abs(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// float64x1_t vabs_f64 (float64x1_t a)
+        // ///   A32: VABS.F64 Dd, Dm
+        // ///   A64: FABS Dd, Dn
+        // /// </summary>
+        // public static Vector64<double> AbsScalar(Vector64<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A32: VABS.F32 Sd, Sm
+        ///   A64: FABS Sd, Sn
+        /// </summary>
+        public static Vector64<float> AbsScalar(Vector64<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vadd_u8 (uint8x8_t a, uint8x8_t b)
+        ///   A32: VADD.I8 Dd, Dn, Dm
+        ///   A64: ADD Vd.8B, Vn.8B, Vm.8B
+        /// </summary>
+        public static Vector64<byte> Add(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vadd_s16 (int16x4_t a, int16x4_t b)
+        ///   A32: VADD.I16 Dd, Dn, Dm
+        ///   A64: ADD Vd.4H, Vn.4H, Vm.4H
+        /// </summary>
+        public static Vector64<short> Add(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vadd_s32 (int32x2_t a, int32x2_t b)
+        ///   A32: VADD.I32 Dd, Dn, Dm
+        ///   A64: ADD Vd.2S, Vn.2S, Vm.2S
+        /// </summary>
+        public static Vector64<int> Add(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vadd_s8 (int8x8_t a, int8x8_t b)
+        ///   A32: VADD.I8 Dd, Dn, Dm
+        ///   A64: ADD Vd.8B, Vn.8B, Vm.8B
+        /// </summary>
+        public static Vector64<sbyte> Add(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x2_t vadd_f32 (float32x2_t a, float32x2_t b)
+        ///   A32: VADD.F32 Dd, Dn, Dm
+        ///   A64: FADD Vd.2S, Vn.2S, Vm.2S
+        /// </summary>
+        public static Vector64<float> Add(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vadd_u16 (uint16x4_t a, uint16x4_t b)
+        ///   A32: VADD.I16 Dd, Dn, Dm
+        ///   A64: ADD Vd.4H, Vn.4H, Vm.4H
+        /// </summary>
+        public static Vector64<ushort> Add(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vadd_u32 (uint32x2_t a, uint32x2_t b)
+        ///   A32: VADD.I32 Dd, Dn, Dm
+        ///   A64: ADD Vd.2S, Vn.2S, Vm.2S
+        /// </summary>
+        public static Vector64<uint> Add(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vaddq_u8 (uint8x16_t a, uint8x16_t b)
+        ///   A32: VADD.I8 Qd, Qn, Qm
+        ///   A64: ADD Vd.16B, Vn.16B, Vm.16B
+        /// </summary>
+        public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vaddq_s16 (int16x8_t a, int16x8_t b)
+        ///   A32: VADD.I16 Qd, Qn, Qm
+        ///   A64: ADD Vd.8H, Vn.8H, Vm.8H
+        /// </summary>
+        public static Vector128<short> Add(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vaddq_s32 (int32x4_t a, int32x4_t b)
+        ///   A32: VADD.I32 Qd, Qn, Qm
+        ///   A64: ADD Vd.4S, Vn.4S, Vm.4S
+        /// </summary>
+        public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vaddq_s64 (int64x2_t a, int64x2_t b)
+        ///   A32: VADD.I64 Qd, Qn, Qm
+        ///   A64: ADD Vd.2D, Vn.2D, Vm.2D
+        /// </summary>
+        public static Vector128<long> Add(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vaddq_s8 (int8x16_t a, int8x16_t b)
+        ///   A32: VADD.I8 Qd, Qn, Qm
+        ///   A64: ADD Vd.16B, Vn.16B, Vm.16B
+        /// </summary>
+        public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vaddq_f32 (float32x4_t a, float32x4_t b)
+        ///   A32: VADD.F32 Qd, Qn, Qm
+        ///   A64: FADD Vd.4S, Vn.4S, Vm.4S
+        /// </summary>
+        public static Vector128<float> Add(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vaddq_u16 (uint16x8_t a, uint16x8_t b)
+        ///   A32: VADD.I16 Qd, Qn, Qm
+        ///   A64: ADD Vd.8H, Vn.8H, Vm.8H
+        /// </summary>
+        public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vaddq_u32 (uint32x4_t a, uint32x4_t b)
+        ///   A32: VADD.I32 Qd, Qn, Qm
+        ///   A64: ADD Vd.4S, Vn.4S, Vm.4S
+        /// </summary>
+        public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vaddq_u64 (uint64x2_t a, uint64x2_t b)
+        ///   A32: VADD.I64 Qd, Qn, Qm
+        ///   A64: ADD Vd.2D, Vn.2D, Vm.2D
+        /// </summary>
+        public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// float64x1_t vadd_f64 (float64x1_t a, float64x1_t b)
+        // ///   A32: VADD.F64 Dd, Dn, Dm
+        // ///   A64: FADD Dd, Dn, Dm
+        // /// </summary>
+        // public static Vector64<double> AddScalar(Vector64<double> left, Vector64<double> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int64x1_t vadd_s64 (int64x1_t a, int64x1_t b)
+        // ///   A32: VADD.I64 Dd, Dn, Dm
+        // ///   A64: ADD Dd, Dn, Dm
+        // /// </summary>
+        // public static Vector64<long> AddScalar(Vector64<long> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// uint64x1_t vadd_u64 (uint64x1_t a, uint64x1_t b)
+        // ///   A32: VADD.I64 Dd, Dn, Dm
+        // ///   A64: ADD Dd, Dn, Dm
+        // /// </summary>
+        // public static Vector64<ulong> AddScalar(Vector64<ulong> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A32: VADD.F32 Sd, Sn, Sm
+        ///   A64:
+        /// </summary>
+        public static Vector64<float> AddScalar(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vld1_u8 (uint8_t const * ptr)
+        ///   A32: VLD1.8 Dd, [Rn]
+        ///   A64: LD1 Vt.8B, [Xn]
+        /// </summary>
+        public static unsafe Vector64<byte> LoadVector64(byte* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vld1_s16 (int16_t const * ptr)
+        ///   A32: VLD1.16 Dd, [Rn]
+        ///   A64: LD1 Vt.4H, [Xn]
+        /// </summary>
+        public static unsafe Vector64<short> LoadVector64(short* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vld1_s32 (int32_t const * ptr)
+        ///   A32: VLD1.32 Dd, [Rn]
+        ///   A64: LD1 Vt.2S, [Xn]
+        /// </summary>
+        public static unsafe Vector64<int> LoadVector64(int* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vld1_s8 (int8_t const * ptr)
+        ///   A32: VLD1.8 Dd, [Rn]
+        ///   A64: LD1 Vt.8B, [Xn]
+        /// </summary>
+        public static unsafe Vector64<sbyte> LoadVector64(sbyte* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x2_t vld1_f32 (float32_t const * ptr)
+        ///   A32: VLD1.32 Dd, [Rn]
+        ///   A64: LD1 Vt.2S, [Xn]
+        /// </summary>
+        public static unsafe Vector64<float> LoadVector64(float* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vld1_u16 (uint16_t const * ptr)
+        ///   A32: VLD1.16 Dd, [Rn]
+        ///   A64: LD1 Vt.4H, [Xn]
+        /// </summary>
+        public static unsafe Vector64<ushort> LoadVector64(ushort* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vld1_u32 (uint32_t const * ptr)
+        ///   A32: VLD1.32 Dd, [Rn]
+        ///   A64: LD1 Vt.2S, [Xn]
+        /// </summary>
+        public static unsafe Vector64<uint> LoadVector64(uint* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vld1q_u8 (uint8_t const * ptr)
+        ///   A32: VLD1.8 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.16B, [Xn]
+        /// </summary>
+        public static unsafe Vector128<byte> LoadVector128(byte* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vld1q_f64 (float64_t const * ptr)
+        ///   A32: VLD1.64 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.2D, [Xn]
+        /// </summary>
+        public static unsafe Vector128<double> LoadVector128(double* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vld1q_s16 (int16_t const * ptr)
+        ///   A32: VLD1.16 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.8H, [Xn]
+        /// </summary>
+        public static unsafe Vector128<short> LoadVector128(short* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vld1q_s32 (int32_t const * ptr)
+        ///   A32: VLD1.32 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.4S, [Xn]
+        /// </summary>
+        public static unsafe Vector128<int> LoadVector128(int* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vld1q_s64 (int64_t const * ptr)
+        ///   A32: VLD1.64 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.2D, [Xn]
+        /// </summary>
+        public static unsafe Vector128<long> LoadVector128(long* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vld1q_s8 (int8_t const * ptr)
+        ///   A32: VLD1.8 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.16B, [Xn]
+        /// </summary>
+        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vld1q_f32 (float32_t const * ptr)
+        ///   A32: VLD1.32 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.4S, [Xn]
+        /// </summary>
+        public static unsafe Vector128<float> LoadVector128(float* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vld1q_s16 (uint16_t const * ptr)
+        ///   A32: VLD1.16 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.8H, [Xn]
+        /// </summary>
+        public static unsafe Vector128<ushort> LoadVector128(ushort* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vld1q_s32 (uint32_t const * ptr)
+        ///   A32: VLD1.32 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.4S, [Xn]
+        /// </summary>
+        public static unsafe Vector128<uint> LoadVector128(uint* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vld1q_u64 (uint64_t const * ptr)
+        ///   A32: VLD1.64 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.2D, [Xn]
+        /// </summary>
+        public static unsafe Vector128<ulong> LoadVector128(ulong* address) { throw new PlatformNotSupportedException(); }
+    }
+}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs
new file mode 100644 (file)
index 0000000..8d0b5e3
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs
@@ -0,0 +1,377 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.Arm
+{
+    /// <summary>
+    /// This class provides access to the ARM AdvSIMD hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class AdvSimd : ArmBase
+    {
+        internal AdvSimd() { }
+
+        public static new bool IsSupported { get => IsSupported; }
+
+        [Intrinsic]
+        public new abstract class Arm64 : ArmBase.Arm64
+        {
+            public static new bool IsSupported { get => IsSupported; }
+
+            /// <summary>
+            /// float64x2_t vabsq_f64 (float64x2_t a)
+            ///   A64: FABS Vd.2D, Vn.2D
+            /// </summary>
+            public static Vector128<double> Abs(Vector128<double> value) => Abs(value);
+
+            /// <summary>
+            /// int64x2_t vabsq_s64 (int64x2_t a)
+            ///   A64: ABS Vd.2D, Vn.2D
+            /// </summary>
+            public static Vector128<ulong> Abs(Vector128<long> value) => Abs(value);
+
+            // /// <summary>
+            // /// int64x1_t vabs_s64 (int64x1_t a)
+            // ///   A64: ABS Dd, Dn
+            // /// </summary>
+            // public static Vector64<ulong> AbsScalar(Vector64<long> value) => AbsScalar(value);
+
+            /// <summary>
+            /// float64x2_t vaddq_f64 (float64x2_t a, float64x2_t b)
+            ///   A64: FADD Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<double> Add(Vector128<double> left, Vector128<float> right) => Add(left, right);
+        }
+
+        /// <summary>
+        /// int8x8_t vabs_s8 (int8x8_t a)
+        ///   A32: VABS.S8 Dd, Dm
+        ///   A64: ABS Vd.8B, Vn.8B
+        /// </summary>
+        public static Vector64<byte> Abs(Vector64<sbyte> value) => Abs(value);
+
+        /// <summary>
+        /// int16x4_t vabs_s16 (int16x4_t a)
+        ///   A32: VABS.S16 Dd, Dm
+        ///   A64: ABS Vd.4H, Vn.4H
+        /// </summary>
+        public static Vector64<ushort> Abs(Vector64<short> value) => Abs(value);
+
+        /// <summary>
+        /// int32x2_t vabs_s32 (int32x2_t a)
+        ///   A32: VABS.S32 Dd, Dm
+        ///   A64: ABS Vd.2S, Vn.2S
+        /// </summary>
+        public static Vector64<uint> Abs(Vector64<int> value) => Abs(value);
+
+        /// <summary>
+        /// float32x2_t vabs_f32 (float32x2_t a)
+        ///   A32: VABS.F32 Dd, Dm
+        ///   A64: FABS Vd.2S, Vn.2S
+        /// </summary>
+        public static Vector64<float> Abs(Vector64<float> value) => Abs(value);
+
+        /// <summary>
+        /// int8x16_t vabsq_s8 (int8x16_t a)
+        ///   A32: VABS.S8 Qd, Qm
+        ///   A64: ABS Vd.16B, Vn.16B
+        /// </summary>
+        public static Vector128<byte> Abs(Vector128<sbyte> value) => Abs(value);
+
+        /// <summary>
+        /// int16x8_t vabsq_s16 (int16x8_t a)
+        ///   A32: VABS.S16 Qd, Qm
+        ///   A64: ABS Vd.8H, Vn.8H
+        /// </summary>
+        public static Vector128<ushort> Abs(Vector128<short> value) => Abs(value);
+
+        /// <summary>
+        /// int32x4_t vabsq_s32 (int32x4_t a)
+        ///   A32: VABS.S32 Qd, Qm
+        ///   A64: ABS Vd.4S, Vn.4S
+        /// </summary>
+        public static Vector128<uint> Abs(Vector128<int> value) => Abs(value);
+
+        /// <summary>
+        /// float32x4_t vabsq_f32 (float32x4_t a)
+        ///   A32: VABS.F32 Qd, Qm
+        ///   A64: FABS Vd.4S, Vn.4S
+        /// </summary>
+        public static Vector128<float> Abs(Vector128<float> value) => Abs(value);
+
+        // /// <summary>
+        // /// float64x1_t vabs_f64 (float64x1_t a)
+        // ///   A32: VABS.F64 Dd, Dm
+        // ///   A64: FABS Dd, Dn
+        // /// </summary>
+        // public static Vector64<double> AbsScalar(Vector64<double> value) => Abs(value);
+
+        /// <summary>
+        ///   A32: VABS.F32 Sd, Sm
+        ///   A64: FABS Sd, Sn
+        /// </summary>
+        public static Vector64<float> AbsScalar(Vector64<float> value) => Abs(value);
+
+        /// <summary>
+        /// uint8x8_t vadd_u8 (uint8x8_t a, uint8x8_t b)
+        ///   A32: VADD.I8 Dd, Dn, Dm
+        ///   A64: ADD Vd.8B, Vn.8B, Vm.8B
+        /// </summary>
+        public static Vector64<byte> Add(Vector64<byte> left, Vector64<byte> right) => Add(left, right);
+
+        /// <summary>
+        /// int16x4_t vadd_s16 (int16x4_t a, int16x4_t b)
+        ///   A32: VADD.I16 Dd, Dn, Dm
+        ///   A64: ADD Vd.4H, Vn.4H, Vm.4H
+        /// </summary>
+        public static Vector64<short> Add(Vector64<short> left, Vector64<short> right) => Add(left, right);
+
+        /// <summary>
+        /// int32x2_t vadd_s32 (int32x2_t a, int32x2_t b)
+        ///   A32: VADD.I32 Dd, Dn, Dm
+        ///   A64: ADD Vd.2S, Vn.2S, Vm.2S
+        /// </summary>
+        public static Vector64<int> Add(Vector64<int> left, Vector64<int> right) => Add(left, right);
+
+        /// <summary>
+        /// int8x8_t vadd_s8 (int8x8_t a, int8x8_t b)
+        ///   A32: VADD.I8 Dd, Dn, Dm
+        ///   A64: ADD Vd.8B, Vn.8B, Vm.8B
+        /// </summary>
+        public static Vector64<sbyte> Add(Vector64<sbyte> left, Vector64<sbyte> right) => Add(left, right);
+
+        /// <summary>
+        /// float32x2_t vadd_f32 (float32x2_t a, float32x2_t b)
+        ///   A32: VADD.F32 Dd, Dn, Dm
+        ///   A64: FADD Vd.2S, Vn.2S, Vm.2S
+        /// </summary>
+        public static Vector64<float> Add(Vector64<float> left, Vector64<float> right) => Add(left, right);
+
+        /// <summary>
+        /// uint16x4_t vadd_u16 (uint16x4_t a, uint16x4_t b)
+        ///   A32: VADD.I16 Dd, Dn, Dm
+        ///   A64: ADD Vd.4H, Vn.4H, Vm.4H
+        /// </summary>
+        public static Vector64<ushort> Add(Vector64<ushort> left, Vector64<ushort> right) => Add(left, right);
+
+        /// <summary>
+        /// uint32x2_t vadd_u32 (uint32x2_t a, uint32x2_t b)
+        ///   A32: VADD.I32 Dd, Dn, Dm
+        ///   A64: ADD Vd.2S, Vn.2S, Vm.2S
+        /// </summary>
+        public static Vector64<uint> Add(Vector64<uint> left, Vector64<uint> right) => Add(left, right);
+
+        /// <summary>
+        /// uint8x16_t vaddq_u8 (uint8x16_t a, uint8x16_t b)
+        ///   A32: VADD.I8 Qd, Qn, Qm
+        ///   A64: ADD Vd.16B, Vn.16B, Vm.16B
+        /// </summary>
+        public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right) => Add(left, right);
+
+        /// <summary>
+        /// int16x8_t vaddq_s16 (int16x8_t a, int16x8_t b)
+        ///   A32: VADD.I16 Qd, Qn, Qm
+        ///   A64: ADD Vd.8H, Vn.8H, Vm.8H
+        /// </summary>
+        public static Vector128<short> Add(Vector128<short> left, Vector128<short> right) => Add(left, right);
+
+        /// <summary>
+        /// int32x4_t vaddq_s32 (int32x4_t a, int32x4_t b)
+        ///   A32: VADD.I32 Qd, Qn, Qm
+        ///   A64: ADD Vd.4S, Vn.4S, Vm.4S
+        /// </summary>
+        public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) => Add(left, right);
+
+        /// <summary>
+        /// int64x2_t vaddq_s64 (int64x2_t a, int64x2_t b)
+        ///   A32: VADD.I64 Qd, Qn, Qm
+        ///   A64: ADD Vd.2D, Vn.2D, Vm.2D
+        /// </summary>
+        public static Vector128<long> Add(Vector128<long> left, Vector128<long> right) => Add(left, right);
+
+        /// <summary>
+        /// int8x16_t vaddq_s8 (int8x16_t a, int8x16_t b)
+        ///   A32: VADD.I8 Qd, Qn, Qm
+        ///   A64: ADD Vd.16B, Vn.16B, Vm.16B
+        /// </summary>
+        public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right) => Add(left, right);
+
+        /// <summary>
+        /// float32x4_t vaddq_f32 (float32x4_t a, float32x4_t b)
+        ///   A32: VADD.F32 Qd, Qn, Qm
+        ///   A64: FADD Vd.4S, Vn.4S, Vm.4S
+        /// </summary>
+        public static Vector128<float> Add(Vector128<float> left, Vector128<float> right) => Add(left, right);
+
+        /// <summary>
+        /// uint16x8_t vaddq_u16 (uint16x8_t a, uint16x8_t b)
+        ///   A32: VADD.I16 Qd, Qn, Qm
+        ///   A64: ADD Vd.8H, Vn.8H, Vm.8H
+        /// </summary>
+        public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right) => Add(left, right);
+
+        /// <summary>
+        /// uint32x4_t vaddq_u32 (uint32x4_t a, uint32x4_t b)
+        ///   A32: VADD.I32 Qd, Qn, Qm
+        ///   A64: ADD Vd.4S, Vn.4S, Vm.4S
+        /// </summary>
+        public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) => Add(left, right);
+
+        /// <summary>
+        /// uint64x2_t vaddq_u64 (uint64x2_t a, uint64x2_t b)
+        ///   A32: VADD.I64 Qd, Qn, Qm
+        ///   A64: ADD Vd.2D, Vn.2D, Vm.2D
+        /// </summary>
+        public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right) => Add(left, right);
+
+        // /// <summary>
+        // /// float64x1_t vadd_f64 (float64x1_t a, float64x1_t b)
+        // ///   A32: VADD.F64 Dd, Dn, Dm
+        // ///   A64: FADD Dd, Dn, Dm
+        // /// </summary>
+        // public static Vector64<double> AddScalar(Vector64<double> left, Vector64<double> right) => Add(left, right);
+
+        // /// <summary>
+        // /// int64x1_t vadd_s64 (int64x1_t a, int64x1_t b)
+        // ///   A32: VADD.I64 Dd, Dn, Dm
+        // ///   A64: ADD Dd, Dn, Dm
+        // /// </summary>
+        // public static Vector64<long> AddScalar(Vector64<long> left, Vector64<long> right) => AddScalar(left, right);
+
+        // /// <summary>
+        // /// uint64x1_t vadd_u64 (uint64x1_t a, uint64x1_t b)
+        // ///   A32: VADD.I64 Dd, Dn, Dm
+        // ///   A64: ADD Dd, Dn, Dm
+        // /// </summary>
+        // public static Vector64<ulong> AddScalar(Vector64<ulong> left, Vector64<ulong> right) => AddScalar(left, right);
+
+        /// <summary>
+        ///   A32: VADD.F32 Sd, Sn, Sm
+        ///   A64:
+        /// </summary>
+        public static Vector64<float> AddScalar(Vector64<float> left, Vector64<float> right) => Add(left, right);
+
+        /// <summary>
+        /// uint8x8_t vld1_u8 (uint8_t const * ptr)
+        ///   A32: VLD1.8 Dd, [Rn]
+        ///   A64: LD1 Vt.8B, [Xn]
+        /// </summary>
+        public static unsafe Vector64<byte> LoadVector64(byte* address) => LoadVector64(address);
+
+        /// <summary>
+        /// int16x4_t vld1_s16 (int16_t const * ptr)
+        ///   A32: VLD1.16 Dd, [Rn]
+        ///   A64: LD1 Vt.4H, [Xn]
+        /// </summary>
+        public static unsafe Vector64<short> LoadVector64(short* address) => LoadVector64(address);
+
+        /// <summary>
+        /// int32x2_t vld1_s32 (int32_t const * ptr)
+        ///   A32: VLD1.32 Dd, [Rn]
+        ///   A64: LD1 Vt.2S, [Xn]
+        /// </summary>
+        public static unsafe Vector64<int> LoadVector64(int* address) => LoadVector64(address);
+
+        /// <summary>
+        /// int8x8_t vld1_s8 (int8_t const * ptr)
+        ///   A32: VLD1.8 Dd, [Rn]
+        ///   A64: LD1 Vt.8B, [Xn]
+        /// </summary>
+        public static unsafe Vector64<sbyte> LoadVector64(sbyte* address) => LoadVector64(address);
+
+        /// <summary>
+        /// float32x2_t vld1_f32 (float32_t const * ptr)
+        ///   A32: VLD1.32 Dd, [Rn]
+        ///   A64: LD1 Vt.2S, [Xn]
+        /// </summary>
+        public static unsafe Vector64<float> LoadVector64(float* address) => LoadVector64(address);
+
+        /// <summary>
+        /// uint16x4_t vld1_u16 (uint16_t const * ptr)
+        ///   A32: VLD1.16 Dd, [Rn]
+        ///   A64: LD1 Vt.4H, [Xn]
+        /// </summary>
+        public static unsafe Vector64<ushort> LoadVector64(ushort* address) => LoadVector64(address);
+
+        /// <summary>
+        /// uint32x2_t vld1_u32 (uint32_t const * ptr)
+        ///   A32: VLD1.32 Dd, [Rn]
+        ///   A64: LD1 Vt.2S, [Xn]
+        /// </summary>
+        public static unsafe Vector64<uint> LoadVector64(uint* address) => LoadVector64(address);
+
+        /// <summary>
+        /// uint8x16_t vld1q_u8 (uint8_t const * ptr)
+        ///   A32: VLD1.8 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.16B, [Xn]
+        /// </summary>
+        public static unsafe Vector128<byte> LoadVector128(byte* address) => LoadVector128(address);
+
+        /// <summary>
+        /// float64x2_t vld1q_f64 (float64_t const * ptr)
+        ///   A32: VLD1.64 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.2D, [Xn]
+        /// </summary>
+        public static unsafe Vector128<double> LoadVector128(double* address) => LoadVector128(address);
+
+        /// <summary>
+        /// int16x8_t vld1q_s16 (int16_t const * ptr)
+        ///   A32: VLD1.16 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.8H, [Xn]
+        /// </summary>
+        public static unsafe Vector128<short> LoadVector128(short* address) => LoadVector128(address);
+
+        /// <summary>
+        /// int32x4_t vld1q_s32 (int32_t const * ptr)
+        ///   A32: VLD1.32 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.4S, [Xn]
+        /// </summary>
+        public static unsafe Vector128<int> LoadVector128(int* address) => LoadVector128(address);
+
+        /// <summary>
+        /// int64x2_t vld1q_s64 (int64_t const * ptr)
+        ///   A32: VLD1.64 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.2D, [Xn]
+        /// </summary>
+        public static unsafe Vector128<long> LoadVector128(long* address) => LoadVector128(address);
+
+        /// <summary>
+        /// int8x16_t vld1q_s8 (int8_t const * ptr)
+        ///   A32: VLD1.8 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.16B, [Xn]
+        /// </summary>
+        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address) => LoadVector128(address);
+
+        /// <summary>
+        /// float32x4_t vld1q_f32 (float32_t const * ptr)
+        ///   A32: VLD1.32 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.4S, [Xn]
+        /// </summary>
+        public static unsafe Vector128<float> LoadVector128(float* address) => LoadVector128(address);
+
+        /// <summary>
+        /// uint16x8_t vld1q_s16 (uint16_t const * ptr)
+        ///   A32: VLD1.16 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.8H, [Xn]
+        /// </summary>
+        public static unsafe Vector128<ushort> LoadVector128(ushort* address) => LoadVector128(address);
+
+        /// <summary>
+        /// uint32x4_t vld1q_s32 (uint32_t const * ptr)
+        ///   A32: VLD1.32 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.4S, [Xn]
+        /// </summary>
+        public static unsafe Vector128<uint> LoadVector128(uint* address) => LoadVector128(address);
+
+        /// <summary>
+        /// uint64x2_t vld1q_u64 (uint64_t const * ptr)
+        ///   A32: VLD1.64 Dd, Dd+1, [Rn]
+        ///   A64: LD1 Vt.2D, [Xn]
+        /// </summary>
+        public static unsafe Vector128<ulong> LoadVector128(ulong* address) => LoadVector128(address);
+    }
+}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs
new file mode 100644 (file)
index 0000000..8f62ae5
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs
@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#pragma warning disable IDE0060 // unused parameters
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.Arm
+{
+    /// <summary>
+    /// This class provides access to the ARM AES hardware instructions via intrinsics
+    /// </summary>
+    [CLSCompliant(false)]
+    public abstract class Aes : ArmBase
+    {
+        internal Aes() { }
+
+        public static new bool IsSupported { [Intrinsic] get => false; }
+
+        /// <summary>
+        /// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key)
+        ///   A32: AESD.8 Qd, Qm
+        ///   A64: AESD Vd.16B, Vn.16B
+        /// </summary>
+        public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vaeseq_u8 (uint8x16_t data, uint8x16_t key)
+        ///   A32: AESE.8 Qd, Qm
+        ///   A64: AESE Vd.16B, Vn.16B
+        /// </summary>
+        public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vaesimcq_u8 (uint8x16_t data)
+        ///   A32: AESIMC.8 Qd, Qm
+        ///   A64: AESIMC Vd.16B, Vn.16B
+        /// </summary>
+        public static Vector128<byte> InverseMixColumns(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vaesmcq_u8 (uint8x16_t data)
+        ///   A32: AESMC.8 Qd, Qm
+        ///   A64: AESMC V>.16B, Vn.16B
+        /// </summary>
+        public static Vector128<byte> MixColumns(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+    }
+}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs
new file mode 100644 (file)
index 0000000..fb0a1c6
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs
@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.Arm
+{
+    /// <summary>
+    /// This class provides access to the ARM AES hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class Aes : ArmBase
+    {
+        internal Aes() { }
+
+        public static new bool IsSupported { get => IsSupported; }
+
+        /// <summary>
+        /// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key)
+        ///   A32: AESD.8 Qd, Qm
+        ///   A64: AESD Vd.16B, Vn.16B
+        /// </summary>
+        public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey) => Decrypt(value, roundKey);
+
+        /// <summary>
+        /// uint8x16_t vaeseq_u8 (uint8x16_t data, uint8x16_t key)
+        ///   A32: AESE.8 Qd, Qm
+        ///   A64: AESE Vd.16B, Vn.16B
+        /// </summary>
+        public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey) => Encrypt(value, roundKey);
+
+        /// <summary>
+        /// uint8x16_t vaesimcq_u8 (uint8x16_t data)
+        ///   A32: AESIMC.8 Qd, Qm
+        ///   A64: AESIMC Vd.16B, Vn.16B
+        /// </summary>
+        public static Vector128<byte> InverseMixColumns(Vector128<byte> value) => InverseMixColumns(value);
+
+        /// <summary>
+        /// uint8x16_t vaesmcq_u8 (uint8x16_t data)
+        ///   A32: AESMC.8 Qd, Qm
+        ///   A64: AESMC V>.16B, Vn.16B
+        /// </summary>
+        public static Vector128<byte> MixColumns(Vector128<byte> value) => MixColumns(value);
+    }
+}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Aes.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Aes.PlatformNotSupported.cs
deleted file mode 100644 (file)
index bfacc5b..0000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Aes.PlatformNotSupported.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#pragma warning disable IDE0060 // unused parameters
-using System.Runtime.CompilerServices;
-
-namespace System.Runtime.Intrinsics.Arm.Arm64
-{
-    /// <summary>
-    /// This class provides access to the Arm64 AES Crypto intrinsics
-    ///
-    /// Arm64 CPU indicate support for this feature by setting
-    /// ID_AA64ISAR0_EL1.AES is 1 or better
-    /// </summary>
-    [CLSCompliant(false)]
-    public static class Aes
-    {
-        public static bool IsSupported { [Intrinsic] get => false; }
-
-        /// <summary>
-        /// Performs AES single round decryption
-        /// vaesdq_u8 (uint8x16_t data, uint8x16_t key)
-        /// </summary>
-        public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs AES single round encryption
-        /// vaeseq_u8 (uint8x16_t data, uint8x16_t key)
-        /// </summary>
-        public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs AES  Mix Columns
-        /// vaesmcq_u8 (uint8x16_t data)
-        /// </summary>
-        public static Vector128<byte> MixColumns(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs AES inverse mix columns
-        /// vaesimcq_u8  (uint8x16_t data)
-        /// </summary>
-        public static Vector128<byte> InverseMixColumns(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
-    }
-}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Aes.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Aes.cs
deleted file mode 100644 (file)
index c4f2dc0..0000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Aes.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.Intrinsics;
-
-namespace System.Runtime.Intrinsics.Arm.Arm64
-{
-    /// <summary>
-    /// This class provides access to the Arm64 AES Crypto intrinsics
-    ///
-    /// Arm64 CPU indicate support for this feature by setting
-    /// ID_AA64ISAR0_EL1.AES is 1 or better
-    /// </summary>
-    [Intrinsic]
-    [CLSCompliant(false)]
-    public static class Aes
-    {
-        public static bool IsSupported { get => IsSupported; }
-        /// <summary>
-        /// Performs AES single round decryption
-        /// vaesdq_u8 (uint8x16_t data, uint8x16_t key)
-        /// </summary>
-        public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey) => Decrypt(value, roundKey);
-
-        /// <summary>
-        /// Performs AES single round encryption
-        /// vaeseq_u8 (uint8x16_t data, uint8x16_t key)
-        /// </summary>
-        public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey) => Encrypt(value, roundKey);
-
-        /// <summary>
-        /// Performs AES  Mix Columns
-        /// vaesmcq_u8 (uint8x16_t data)
-        /// </summary>
-        public static Vector128<byte> MixColumns(Vector128<byte> value) => MixColumns(value);
-
-        /// <summary>
-        /// Performs AES inverse mix columns
-        /// vaesimcq_u8  (uint8x16_t data)
-        /// </summary>
-        public static Vector128<byte> InverseMixColumns(Vector128<byte> value) => InverseMixColumns(value);
-    }
-}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Base.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Base.PlatformNotSupported.cs
deleted file mode 100644 (file)
index bc97958..0000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Base.PlatformNotSupported.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#pragma warning disable IDE0060 // unused parameters
-using System.Runtime.CompilerServices;
-
-namespace System.Runtime.Intrinsics.Arm.Arm64
-{
-    /// <summary>
-    /// This class provides access to the Arm64 Base intrinsics
-    ///
-    /// These intrinsics are supported by all Arm64 CPUs
-    /// </summary>
-    [CLSCompliant(false)]
-    public static class Base
-    {
-        public static bool IsSupported { [Intrinsic] get => false; }
-
-        /// <summary>
-        /// Vector LeadingSignCount
-        /// Corresponds to integer forms of ARM64 CLS
-        /// </summary>
-        public static int LeadingSignCount(int value) { throw new PlatformNotSupportedException(); }
-        public static int LeadingSignCount(long value) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector LeadingZeroCount
-        /// Corresponds to integer forms of ARM64 CLZ
-        /// </summary>
-        public static int LeadingZeroCount(int value) { throw new PlatformNotSupportedException(); }
-        public static int LeadingZeroCount(uint value) { throw new PlatformNotSupportedException(); }
-        public static int LeadingZeroCount(long value) { throw new PlatformNotSupportedException(); }
-        public static int LeadingZeroCount(ulong value) { throw new PlatformNotSupportedException(); }
-    }
-}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Base.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Base.cs
deleted file mode 100644 (file)
index c993c41..0000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Base.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.Intrinsics;
-
-namespace System.Runtime.Intrinsics.Arm.Arm64
-{
-    /// <summary>
-    /// This class provides access to the Arm64 Base intrinsics
-    ///
-    /// These intrinsics are supported by all Arm64 CPUs
-    /// </summary>
-    [Intrinsic]
-    [CLSCompliant(false)]
-    public static class Base
-    {
-        public static bool IsSupported { get { return IsSupported; }}
-
-        /// <summary>
-        /// Vector LeadingSignCount
-        /// Corresponds to integer forms of ARM64 CLS
-        /// </summary>
-        public static int LeadingSignCount(int  value) => LeadingSignCount(value);
-        public static int LeadingSignCount(long value) => LeadingSignCount(value);
-
-        /// <summary>
-        /// Vector LeadingZeroCount
-        /// Corresponds to integer forms of ARM64 CLZ
-        /// </summary>
-        public static int LeadingZeroCount(int   value) => LeadingZeroCount(value);
-        public static int LeadingZeroCount(uint  value) => LeadingZeroCount(value);
-        public static int LeadingZeroCount(long  value) => LeadingZeroCount(value);
-        public static int LeadingZeroCount(ulong value) => LeadingZeroCount(value);
-    }
-}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha1.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha1.PlatformNotSupported.cs
deleted file mode 100644 (file)
index 2c73389..0000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha1.PlatformNotSupported.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#pragma warning disable IDE0060 // unused parameters
-using System.Runtime.CompilerServices;
-
-namespace System.Runtime.Intrinsics.Arm.Arm64
-{
-    /// <summary>
-    /// This class provides access to the Arm64 SHA1 Crypto intrinsics
-    ///
-    /// Arm64 CPU indicate support for this feature by setting
-    /// ID_AA64ISAR0_EL1.SHA1 is 1 or better
-    /// </summary>
-    [CLSCompliant(false)]
-    public static class Sha1
-    {
-        public static bool IsSupported { [Intrinsic] get => false; }
-
-        /// <summary>
-        /// Performs SHA1 hash update choose form.
-        /// vsha1cq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
-        /// </summary>
-        public static Vector128<uint> HashChoose(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs SHA1 hash update majority form.
-        /// vsha1mq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
-        /// </summary>
-        public static Vector128<uint> HashMajority(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs SHA1 hash update parity form.
-        /// vsha1pq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
-        /// </summary>
-        public static Vector128<uint> HashParity(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs SHA1 fixed rotate
-        /// vsha1h_u32 (uint32_t hash_e)
-        /// </summary>
-        public static uint FixedRotate(uint hash_e) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs SHA1 schedule update 0
-        /// vsha1su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7, uint32x4_t w8_11)
-        /// </summary>
-        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7, Vector128<uint> w8_11) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs SHA1 schedule update 1
-        /// vsha1su1q_u32 (uint32x4_t tw0_3, uint32x4_t w12_15)
-        /// </summary>
-        public static Vector128<uint> SchedulePart2(Vector128<uint> tw0_3, Vector128<uint> w12_15) { throw new PlatformNotSupportedException(); }
-    }
-}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha1.cs
deleted file mode 100644 (file)
index a6c1901..0000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha1.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.Intrinsics;
-
-namespace System.Runtime.Intrinsics.Arm.Arm64
-{
-    /// <summary>
-    /// This class provides access to the Arm64 SHA1 Crypto intrinsics
-    ///
-    /// Arm64 CPU indicate support for this feature by setting
-    /// ID_AA64ISAR0_EL1.SHA1 is 1 or better
-    /// </summary>
-    [Intrinsic]
-    [CLSCompliant(false)]
-    public static class Sha1
-    {
-        public static bool IsSupported {  get => IsSupported; }
-
-        /// <summary>
-        /// Performs SHA1 hash update choose form.
-        /// vsha1cq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
-        /// </summary>
-        public static Vector128<uint> HashChoose(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint>wk) => HashChoose(hash_abcd, hash_e, wk);
-
-        /// <summary>
-        /// Performs SHA1 hash update majority form.
-        /// vsha1mq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
-        /// </summary>
-        public static Vector128<uint> HashMajority(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint>wk) => HashMajority(hash_abcd, hash_e, wk);
-
-        /// <summary>
-        /// Performs SHA1 hash update parity form.
-        /// vsha1pq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
-        /// </summary>
-        public static Vector128<uint> HashParity(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint>wk) => HashParity(hash_abcd, hash_e, wk);
-
-        /// <summary>
-        /// Performs SHA1 fixed rotate
-        /// vsha1h_u32 (uint32_t hash_e)
-        /// </summary>
-        public static uint FixedRotate(uint hash_e) => FixedRotate(hash_e);
-
-        /// <summary>
-        /// Performs SHA1 schedule update 0
-        /// vsha1su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7, uint32x4_t w8_11)
-        /// </summary>
-        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7, Vector128<uint> w8_11) => SchedulePart1(w0_3, w4_7, w8_11);
-
-        /// <summary>
-        /// Performs SHA1 schedule update 1
-        /// vsha1su1q_u32 (uint32x4_t tw0_3, uint32x4_t w12_15)
-        /// </summary>
-        public static Vector128<uint> SchedulePart2(Vector128<uint> tw0_3, Vector128<uint> w12_15)  => SchedulePart2(tw0_3, w12_15);
-    }
-}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha256.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha256.PlatformNotSupported.cs
deleted file mode 100644 (file)
index 3141eb0..0000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha256.PlatformNotSupported.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#pragma warning disable IDE0060 // unused parameters
-using System.Runtime.CompilerServices;
-
-namespace System.Runtime.Intrinsics.Arm.Arm64
-{
-    /// <summary>
-    /// This class provides access to the Arm64 SHA256 Crypto intrinsics
-    ///
-    /// Arm64 CPU indicate support for this feature by setting
-    /// ID_AA64ISAR0_EL1.SHA2 is 1 or better
-    /// </summary>
-    [CLSCompliant(false)]
-    public static class Sha256
-    {
-        public static bool IsSupported { [Intrinsic] get => false; }
-
-        /// <summary>
-        /// Performs SHA256 hash update (part 1).
-        /// vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk)
-        /// </summary>
-        public static Vector128<uint> HashLower(Vector128<uint> hash_abcd, Vector128<uint> hash_efgh, Vector128<uint> wk) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs SHA256 hash update (part 2).
-        /// vsha256h2q_u32 (uint32x4_t hash_efgh, uint32x4_t hash_abcd, uint32x4_t wk)
-        /// </summary>
-        public static Vector128<uint> HashUpper(Vector128<uint> hash_efgh, Vector128<uint> hash_abcd, Vector128<uint> wk) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs SHA256 schedule update 0
-        /// vsha256su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7)
-        /// </summary>
-        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Performs SHA256 schedule update 1
-        /// vsha256su1q_u32 (uint32x4_t w0_3, uint32x4_t w8_11, uint32x4_t w12_15)
-        /// </summary>
-        public static Vector128<uint> SchedulePart2(Vector128<uint> w0_3, Vector128<uint> w8_11, Vector128<uint> w12_15) { throw new PlatformNotSupportedException(); }
-    }
-}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha256.cs
deleted file mode 100644 (file)
index 4b4b16d..0000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Sha256.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.Intrinsics;
-
-namespace System.Runtime.Intrinsics.Arm.Arm64
-{
-    /// <summary>
-    /// This class provides access to the Arm64 SHA256 Crypto intrinsics
-    ///
-    /// Arm64 CPU indicate support for this feature by setting
-    /// ID_AA64ISAR0_EL1.SHA2 is 1 or better
-    /// </summary>
-    [Intrinsic]
-    [CLSCompliant(false)]
-    public static class Sha256
-    {
-        public static bool IsSupported { get => IsSupported; }
-
-        /// <summary>
-        /// Performs SHA256 hash update (part 1).
-        /// vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk)
-        /// </summary>
-        public static Vector128<uint> HashLower(Vector128<uint> hash_abcd, Vector128<uint> hash_efgh, Vector128<uint> wk) => HashLower(hash_abcd, hash_efgh, wk);
-
-        /// <summary>
-        /// Performs SHA256 hash update (part 2).
-        /// vsha256h2q_u32 (uint32x4_t hash_efgh, uint32x4_t hash_abcd, uint32x4_t wk)
-        /// </summary>
-        public static Vector128<uint> HashUpper(Vector128<uint> hash_efgh, Vector128<uint> hash_abcd, Vector128<uint> wk) => HashUpper(hash_efgh, hash_abcd, wk);
-
-        /// <summary>
-        /// Performs SHA256 schedule update 0
-        /// vsha256su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7)
-        /// </summary>
-        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7) => SchedulePart1(w0_3, w4_7);
-
-        /// <summary>
-        /// Performs SHA256 schedule update 1
-        /// vsha256su1q_u32 (uint32x4_t tw0_3, uint32x4_t w8_11, uint32x4_t w12_15)
-        /// </summary>
-        public static Vector128<uint> SchedulePart2(Vector128<uint> w0_3, Vector128<uint> w8_11, Vector128<uint> w12_15) => SchedulePart2(w0_3, w8_11, w12_15);
-    }
-}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Simd.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Simd.PlatformNotSupported.cs
deleted file mode 100644 (file)
index f86a236..0000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Simd.PlatformNotSupported.cs
+++ /dev/null
@@ -1,347 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#pragma warning disable IDE0060 // unused parameters
-using System.Runtime.CompilerServices;
-
-namespace System.Runtime.Intrinsics.Arm.Arm64
-{
-    /// <summary>
-    /// This class provides access to the Arm64 AdvSIMD intrinsics
-    ///
-    /// Arm64 CPU indicate support for this feature by setting
-    /// ID_AA64PFR0_EL1.AdvSIMD == 0 or better.
-    /// </summary>
-    [CLSCompliant(false)]
-    public static class Simd
-    {
-        /// <summary>
-        /// IsSupported property indicates whether any method provided
-        /// by this class is supported by the current runtime.
-        /// </summary>
-        public static bool IsSupported { [Intrinsic] get => false; }
-
-        /// <summary>
-        /// Vector abs
-        /// Corresponds to vector forms of ARM64 ABS &amp; FABS
-        /// </summary>
-        public static Vector64<byte> Abs(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<ushort> Abs(Vector64<short> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<uint> Abs(Vector64<int> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<float> Abs(Vector64<float> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<byte> Abs(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<ushort> Abs(Vector128<short> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<uint> Abs(Vector128<int> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<ulong> Abs(Vector128<long> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<float> Abs(Vector128<float> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<double> Abs(Vector128<double> value) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector add
-        /// Corresponds to vector forms of ARM64 ADD &amp; FADD
-        /// </summary>
-        public static Vector64<T> Add<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> Add<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector and
-        /// Corresponds to vector forms of ARM64 AND
-        /// </summary>
-        public static Vector64<T> And<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> And<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector and not
-        /// Corresponds to vector forms of ARM64 BIC
-        /// </summary>
-        public static Vector64<T> AndNot<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> AndNot<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector BitwiseSelect
-        /// For each bit in the vector result[bit] = sel[bit] ? left[bit] : right[bit]
-        /// Corresponds to vector forms of ARM64 BSL (Also BIF &amp; BIT)
-        /// </summary>
-        public static Vector64<T> BitwiseSelect<T>(Vector64<T> sel, Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> BitwiseSelect<T>(Vector128<T> sel, Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector CompareEqual
-        /// For each element result[elem] = (left[elem] == right[elem]) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMEQ &amp; FCMEQ
-        /// </summary>
-        public static Vector64<T> CompareEqual<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> CompareEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector CompareEqualZero
-        /// For each element result[elem] = (left[elem] == 0) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMEQ &amp; FCMEQ
-        /// </summary>
-        public static Vector64<T> CompareEqualZero<T>(Vector64<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> CompareEqualZero<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector CompareGreaterThan
-        /// For each element result[elem] = (left[elem] > right[elem]) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGT/CMHI &amp; FCMGT
-        /// </summary>
-        public static Vector64<T> CompareGreaterThan<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> CompareGreaterThan<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector CompareGreaterThanZero
-        /// For each element result[elem] = (left[elem] > 0) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGT &amp; FCMGT
-        /// </summary>
-        public static Vector64<T> CompareGreaterThanZero<T>(Vector64<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> CompareGreaterThanZero<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector CompareGreaterThanOrEqual
-        /// For each element result[elem] = (left[elem] >= right[elem]) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGE/CMHS &amp; FCMGE
-        /// </summary>
-        public static Vector64<T> CompareGreaterThanOrEqual<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> CompareGreaterThanOrEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector CompareGreaterThanOrEqualZero
-        /// For each element result[elem] = (left[elem] >= 0) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGE &amp; FCMGE
-        /// </summary>
-        public static Vector64<T> CompareGreaterThanOrEqualZero<T>(Vector64<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> CompareGreaterThanOrEqualZero<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector CompareLessThanZero
-        /// For each element result[elem] = (left[elem] &lt; 0) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGT &amp; FCMGT
-        /// </summary>
-        public static Vector64<T> CompareLessThanZero<T>(Vector64<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> CompareLessThanZero<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector CompareLessThanOrEqualZero
-        /// For each element result[elem] = (left[elem] &lt; 0) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGT &amp; FCMGT
-        /// </summary>
-        public static Vector64<T> CompareLessThanOrEqualZero<T>(Vector64<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> CompareLessThanOrEqualZero<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector CompareTest
-        /// For each element result[elem] = (left[elem] &amp; right[elem]) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMTST
-        /// </summary>
-        public static Vector64<T> CompareTest<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> CompareTest<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// TBD Convert...
-
-        /// <summary>
-        /// Vector Divide
-        /// Corresponds to vector forms of ARM64 FDIV
-        /// </summary>
-        public static Vector64<float> Divide(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector extract item
-        ///
-        /// result = vector[index]
-        ///
-        /// Note: In order to be inlined, index must be a JIT time const expression which can be used to
-        /// populate the literal immediate field.  Use of a non constant will result in generation of a switch table
-        ///
-        /// Corresponds to vector forms of ARM64 MOV
-        /// </summary>
-        public static T Extract<T>(Vector64<T> vector, byte index) where T : struct { throw new PlatformNotSupportedException(); }
-        public static T Extract<T>(Vector128<T> vector, byte index) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector insert item
-        ///
-        /// result = vector;
-        /// result[index] = data;
-        ///
-        /// Note: In order to be inlined, index must be a JIT time const expression which can be used to
-        /// populate the literal immediate field.  Use of a non constant will result in generation of a switch table
-        ///
-        /// Corresponds to vector forms of ARM64 INS
-        /// </summary>
-        public static Vector64<T> Insert<T>(Vector64<T> vector, byte index, T data) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> Insert<T>(Vector128<T> vector, byte index, T data) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector LeadingSignCount
-        /// Corresponds to vector forms of ARM64 CLS
-        /// </summary>
-        public static Vector64<sbyte> LeadingSignCount(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<short> LeadingSignCount(Vector64<short> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<int> LeadingSignCount(Vector64<int> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<sbyte> LeadingSignCount(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<short> LeadingSignCount(Vector128<short> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<int> LeadingSignCount(Vector128<int> value) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector LeadingZeroCount
-        /// Corresponds to vector forms of ARM64 CLZ
-        /// </summary>
-        public static Vector64<byte> LeadingZeroCount(Vector64<byte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<sbyte> LeadingZeroCount(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<ushort> LeadingZeroCount(Vector64<ushort> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<short> LeadingZeroCount(Vector64<short> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<uint> LeadingZeroCount(Vector64<uint> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<int> LeadingZeroCount(Vector64<int> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<byte> LeadingZeroCount(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<sbyte> LeadingZeroCount(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<short> LeadingZeroCount(Vector128<short> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<uint> LeadingZeroCount(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<int> LeadingZeroCount(Vector128<int> value) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector max
-        /// Corresponds to vector forms of ARM64 SMAX, UMAX &amp; FMAX
-        /// </summary>
-        public static Vector64<byte> Max(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<sbyte> Max(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<ushort> Max(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<short> Max(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<uint> Max(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<int> Max(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<float> Max(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<short> Max(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<float> Max(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector min
-        /// Corresponds to vector forms of ARM64 SMIN, UMIN &amp; FMIN
-        /// </summary>
-        public static Vector64<byte> Min(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<sbyte> Min(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<ushort> Min(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<short> Min(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<uint> Min(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<int> Min(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<float> Min(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<short> Min(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<float> Min(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
-
-        /// TBD MOV, FMOV
-
-        /// <summary>
-        /// Vector multiply
-        ///
-        /// For each element result[elem] = left[elem] * right[elem]
-        ///
-        /// Corresponds to vector forms of ARM64 MUL &amp; FMUL
-        /// </summary>
-        public static Vector64<byte> Multiply(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<sbyte> Multiply(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<ushort> Multiply(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<short> Multiply(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<uint> Multiply(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<int> Multiply(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
-        public static Vector64<float> Multiply(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
-        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector negate
-        /// Corresponds to vector forms of ARM64 NEG &amp; FNEG
-        /// </summary>
-        public static Vector64<sbyte> Negate(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<short> Negate(Vector64<short> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<int> Negate(Vector64<int> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<float> Negate(Vector64<float> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<sbyte> Negate(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<short> Negate(Vector128<short> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<int> Negate(Vector128<int> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<long> Negate(Vector128<long> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<float> Negate(Vector128<float> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<double> Negate(Vector128<double> value) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector not
-        /// Corresponds to vector forms of ARM64 NOT
-        /// </summary>
-        public static Vector64<T> Not<T>(Vector64<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> Not<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector or
-        /// Corresponds to vector forms of ARM64 ORR
-        /// </summary>
-        public static Vector64<T> Or<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> Or<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector or not
-        /// Corresponds to vector forms of ARM64 ORN
-        /// </summary>
-        public static Vector64<T> OrNot<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> OrNot<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector PopCount
-        /// Corresponds to vector forms of ARM64 CNT
-        /// </summary>
-        public static Vector64<byte> PopCount(Vector64<byte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector64<sbyte> PopCount(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<byte> PopCount(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<sbyte> PopCount(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// SetVector* Fill vector elements by replicating element value
-        ///
-        /// Corresponds to vector forms of ARM64 DUP (general), DUP (element 0), FMOV (vector, immediate)
-        /// </summary>
-        public static Vector64<T> SetAllVector64<T>(T value) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> SetAllVector128<T>(T value) where T : struct { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector square root
-        /// Corresponds to vector forms of ARM64 FRSQRT
-        /// </summary>
-        public static Vector64<float> Sqrt(Vector64<float> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<float> Sqrt(Vector128<float> value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<double> Sqrt(Vector128<double> value) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        /// Vector subtract
-        /// Corresponds to vector forms of ARM64 SUB &amp; FSUB
-        /// </summary>
-        public static Vector64<T> Subtract<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> Subtract<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-
-
-        /// <summary>
-        /// Vector exclusive or
-        /// Corresponds to vector forms of ARM64 EOR
-        /// </summary>
-        public static Vector64<T> Xor<T>(Vector64<T> left, Vector64<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-        public static Vector128<T> Xor<T>(Vector128<T> left, Vector128<T> right) where T : struct { throw new PlatformNotSupportedException(); }
-    }
-}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Simd.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Simd.cs
deleted file mode 100644 (file)
index c71daf1..0000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Arm64/Simd.cs
+++ /dev/null
@@ -1,348 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.Intrinsics;
-
-namespace System.Runtime.Intrinsics.Arm.Arm64
-{
-    /// <summary>
-    /// This class provides access to the Arm64 AdvSIMD intrinsics
-    ///
-    /// Arm64 CPU indicate support for this feature by setting
-    /// ID_AA64PFR0_EL1.AdvSIMD == 0 or better.
-    /// </summary>
-    [Intrinsic]
-    [CLSCompliant(false)]
-    public static class Simd
-    {
-        /// <summary>
-        /// IsSupported property indicates whether any method provided
-        /// by this class is supported by the current runtime.
-        /// </summary>
-        public static bool IsSupported { get => IsSupported; }
-
-        /// <summary>
-        /// Vector abs
-        /// Corresponds to vector forms of ARM64 ABS &amp; FABS
-        /// </summary>
-        public static Vector64<byte>    Abs(Vector64<sbyte>   value) => Abs(value);
-        public static Vector64<ushort>  Abs(Vector64<short>   value) => Abs(value);
-        public static Vector64<uint>    Abs(Vector64<int>     value) => Abs(value);
-        public static Vector64<float>   Abs(Vector64<float>   value) => Abs(value);
-        public static Vector128<byte>   Abs(Vector128<sbyte>  value) => Abs(value);
-        public static Vector128<ushort> Abs(Vector128<short>  value) => Abs(value);
-        public static Vector128<uint>   Abs(Vector128<int>    value) => Abs(value);
-        public static Vector128<ulong>  Abs(Vector128<long>   value) => Abs(value);
-        public static Vector128<float>  Abs(Vector128<float>  value) => Abs(value);
-        public static Vector128<double> Abs(Vector128<double> value) => Abs(value);
-
-        /// <summary>
-        /// Vector add
-        /// Corresponds to vector forms of ARM64 ADD &amp; FADD
-        /// </summary>
-        public static Vector64<T>  Add<T>(Vector64<T>  left, Vector64<T>  right) where T : struct => Add(left, right);
-        public static Vector128<T> Add<T>(Vector128<T> left, Vector128<T> right) where T : struct => Add(left, right);
-
-        /// <summary>
-        /// Vector and
-        /// Corresponds to vector forms of ARM64 AND
-        /// </summary>
-        public static Vector64<T>  And<T>(Vector64<T>  left, Vector64<T>  right) where T : struct => And(left, right);
-        public static Vector128<T> And<T>(Vector128<T> left, Vector128<T> right) where T : struct => And(left, right);
-
-        /// <summary>
-        /// Vector and not
-        /// Corresponds to vector forms of ARM64 BIC
-        /// </summary>
-        public static Vector64<T>  AndNot<T>(Vector64<T>  left, Vector64<T>  right) where T : struct => AndNot(left, right);
-        public static Vector128<T> AndNot<T>(Vector128<T> left, Vector128<T> right) where T : struct => AndNot(left, right);
-
-        /// <summary>
-        /// Vector BitwiseSelect
-        /// For each bit in the vector result[bit] = sel[bit] ? left[bit] : right[bit]
-        /// Corresponds to vector forms of ARM64 BSL (Also BIF &amp; BIT)
-        /// </summary>
-        public static Vector64<T>  BitwiseSelect<T>(Vector64<T>  sel, Vector64<T>  left, Vector64<T>  right) where T : struct => BitwiseSelect(sel, left, right);
-        public static Vector128<T> BitwiseSelect<T>(Vector128<T> sel, Vector128<T> left, Vector128<T> right) where T : struct => BitwiseSelect(sel, left, right);
-
-        /// <summary>
-        /// Vector CompareEqual
-        /// For each element result[elem] = (left[elem] == right[elem]) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMEQ &amp; FCMEQ
-        /// </summary>
-        public static Vector64<T>  CompareEqual<T>(Vector64<T>  left, Vector64<T>  right) where T : struct => CompareEqual(left, right);
-        public static Vector128<T> CompareEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct => CompareEqual(left, right);
-
-        /// <summary>
-        /// Vector CompareEqualZero
-        /// For each element result[elem] = (left[elem] == 0) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMEQ &amp; FCMEQ
-        /// </summary>
-        public static Vector64<T>  CompareEqualZero<T>(Vector64<T>  value) where T : struct => CompareEqualZero(value);
-        public static Vector128<T> CompareEqualZero<T>(Vector128<T> value) where T : struct => CompareEqualZero(value);
-
-        /// <summary>
-        /// Vector CompareGreaterThan
-        /// For each element result[elem] = (left[elem] > right[elem]) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGT/CMHI &amp; FCMGT
-        /// </summary>
-        public static Vector64<T>  CompareGreaterThan<T>(Vector64<T>  left, Vector64<T>  right) where T : struct => CompareGreaterThan(left, right);
-        public static Vector128<T> CompareGreaterThan<T>(Vector128<T> left, Vector128<T> right) where T : struct => CompareGreaterThan(left, right);
-
-        /// <summary>
-        /// Vector CompareGreaterThanZero
-        /// For each element result[elem] = (left[elem] > 0) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGT &amp; FCMGT
-        /// </summary>
-        public static Vector64<T>  CompareGreaterThanZero<T>(Vector64<T>  value) where T : struct => CompareGreaterThanZero(value);
-        public static Vector128<T> CompareGreaterThanZero<T>(Vector128<T> value) where T : struct => CompareGreaterThanZero(value);
-
-        /// <summary>
-        /// Vector CompareGreaterThanOrEqual
-        /// For each element result[elem] = (left[elem] >= right[elem]) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGE/CMHS &amp; FCMGE
-        /// </summary>
-        public static Vector64<T>  CompareGreaterThanOrEqual<T>(Vector64<T>  left, Vector64<T>    right) where T : struct => CompareGreaterThanOrEqual(left, right);
-        public static Vector128<T> CompareGreaterThanOrEqual<T>(Vector128<T> left, Vector128<T>   right) where T : struct => CompareGreaterThanOrEqual(left, right);
-
-        /// <summary>
-        /// Vector CompareGreaterThanOrEqualZero
-        /// For each element result[elem] = (left[elem] >= 0) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGE &amp; FCMGE
-        /// </summary>
-        public static Vector64<T>  CompareGreaterThanOrEqualZero<T>(Vector64<T>  value) where T : struct => CompareGreaterThanOrEqualZero(value);
-        public static Vector128<T> CompareGreaterThanOrEqualZero<T>(Vector128<T> value) where T : struct => CompareGreaterThanOrEqualZero(value);
-
-        /// <summary>
-        /// Vector CompareLessThanZero
-        /// For each element result[elem] = (left[elem] &lt; 0) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGT &amp; FCMGT
-        /// </summary>
-        public static Vector64<T>  CompareLessThanZero<T>(Vector64<T>  value) where T : struct => CompareLessThanZero(value);
-        public static Vector128<T> CompareLessThanZero<T>(Vector128<T> value) where T : struct => CompareLessThanZero(value);
-
-        /// <summary>
-        /// Vector CompareLessThanOrEqualZero
-        /// For each element result[elem] = (left[elem] &lt; 0) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMGT &amp; FCMGT
-        /// </summary>
-        public static Vector64<T>  CompareLessThanOrEqualZero<T>(Vector64<T>  value) where T : struct => CompareLessThanOrEqualZero(value);
-        public static Vector128<T> CompareLessThanOrEqualZero<T>(Vector128<T> value) where T : struct => CompareLessThanOrEqualZero(value);
-
-        /// <summary>
-        /// Vector CompareTest
-        /// For each element result[elem] = (left[elem] &amp; right[elem]) ? ~0 : 0
-        /// Corresponds to vector forms of ARM64 CMTST
-        /// </summary>
-        public static Vector64<T>  CompareTest<T>(Vector64<T>  left, Vector64<T>  right) where T : struct => CompareTest(left, right);
-        public static Vector128<T> CompareTest<T>(Vector128<T> left, Vector128<T> right) where T : struct => CompareTest(left, right);
-
-        /// TBD Convert...
-
-        /// <summary>
-        /// Vector Divide
-        /// Corresponds to vector forms of ARM64 FDIV
-        /// </summary>
-        public static Vector64<float>   Divide(Vector64<float>   left, Vector64<float>   right) => Divide(left, right);
-        public static Vector128<float>  Divide(Vector128<float>  left, Vector128<float>  right) => Divide(left, right);
-        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) => Divide(left, right);
-
-        /// <summary>
-        /// Vector extract item
-        ///
-        /// result = vector[index]
-        ///
-        /// Note: In order to be inlined, index must be a JIT time const expression which can be used to
-        /// populate the literal immediate field.  Use of a non constant will result in generation of a switch table
-        ///
-        /// Corresponds to vector forms of ARM64 MOV
-        /// </summary>
-        public static T Extract<T>(Vector64<T>  vector, byte index) where T : struct => Extract(vector, index);
-        public static T Extract<T>(Vector128<T> vector, byte index) where T : struct => Extract(vector, index);
-
-        /// <summary>
-        /// Vector insert item
-        ///
-        /// result = vector;
-        /// result[index] = data;
-        ///
-        /// Note: In order to be inlined, index must be a JIT time const expression which can be used to
-        /// populate the literal immediate field.  Use of a non constant will result in generation of a switch table
-        ///
-        /// Corresponds to vector forms of ARM64 INS
-        /// </summary>
-        public static Vector64<T>  Insert<T>(Vector64<T>  vector, byte index, T data) where T : struct => Insert(vector, index, data);
-        public static Vector128<T> Insert<T>(Vector128<T> vector, byte index, T data) where T : struct => Insert(vector, index, data);
-
-        /// <summary>
-        /// Vector LeadingSignCount
-        /// Corresponds to vector forms of ARM64 CLS
-        /// </summary>
-        public static Vector64<sbyte>  LeadingSignCount(Vector64<sbyte>  value) => LeadingSignCount(value);
-        public static Vector64<short>  LeadingSignCount(Vector64<short>  value) => LeadingSignCount(value);
-        public static Vector64<int>    LeadingSignCount(Vector64<int>    value) => LeadingSignCount(value);
-        public static Vector128<sbyte> LeadingSignCount(Vector128<sbyte> value) => LeadingSignCount(value);
-        public static Vector128<short> LeadingSignCount(Vector128<short> value) => LeadingSignCount(value);
-        public static Vector128<int>   LeadingSignCount(Vector128<int>   value) => LeadingSignCount(value);
-
-        /// <summary>
-        /// Vector LeadingZeroCount
-        /// Corresponds to vector forms of ARM64 CLZ
-        /// </summary>
-        public static Vector64<byte>    LeadingZeroCount(Vector64<byte>    value) => LeadingZeroCount(value);
-        public static Vector64<sbyte>   LeadingZeroCount(Vector64<sbyte>   value) => LeadingZeroCount(value);
-        public static Vector64<ushort>  LeadingZeroCount(Vector64<ushort>  value) => LeadingZeroCount(value);
-        public static Vector64<short>   LeadingZeroCount(Vector64<short>   value) => LeadingZeroCount(value);
-        public static Vector64<uint>    LeadingZeroCount(Vector64<uint>    value) => LeadingZeroCount(value);
-        public static Vector64<int>     LeadingZeroCount(Vector64<int>     value) => LeadingZeroCount(value);
-        public static Vector128<byte>   LeadingZeroCount(Vector128<byte>   value) => LeadingZeroCount(value);
-        public static Vector128<sbyte>  LeadingZeroCount(Vector128<sbyte>  value) => LeadingZeroCount(value);
-        public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value) => LeadingZeroCount(value);
-        public static Vector128<short>  LeadingZeroCount(Vector128<short>  value) => LeadingZeroCount(value);
-        public static Vector128<uint>   LeadingZeroCount(Vector128<uint>   value) => LeadingZeroCount(value);
-        public static Vector128<int>    LeadingZeroCount(Vector128<int>    value) => LeadingZeroCount(value);
-
-        /// <summary>
-        /// Vector max
-        /// Corresponds to vector forms of ARM64 SMAX, UMAX &amp; FMAX
-        /// </summary>
-        public static Vector64<byte>    Max(Vector64<byte>    left, Vector64<byte>    right) => Max(left, right);
-        public static Vector64<sbyte>   Max(Vector64<sbyte>   left, Vector64<sbyte>   right) => Max(left, right);
-        public static Vector64<ushort>  Max(Vector64<ushort>  left, Vector64<ushort>  right) => Max(left, right);
-        public static Vector64<short>   Max(Vector64<short>   left, Vector64<short>   right) => Max(left, right);
-        public static Vector64<uint>    Max(Vector64<uint>    left, Vector64<uint>    right) => Max(left, right);
-        public static Vector64<int>     Max(Vector64<int>     left, Vector64<int>     right) => Max(left, right);
-        public static Vector64<float>   Max(Vector64<float>   left, Vector64<float>   right) => Max(left, right);
-        public static Vector128<byte>   Max(Vector128<byte>   left, Vector128<byte>   right) => Max(left, right);
-        public static Vector128<sbyte>  Max(Vector128<sbyte>  left, Vector128<sbyte>  right) => Max(left, right);
-        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right) => Max(left, right);
-        public static Vector128<short>  Max(Vector128<short>  left, Vector128<short>  right) => Max(left, right);
-        public static Vector128<uint>   Max(Vector128<uint>   left, Vector128<uint>   right) => Max(left, right);
-        public static Vector128<int>    Max(Vector128<int>    left, Vector128<int>    right) => Max(left, right);
-        public static Vector128<float>  Max(Vector128<float>  left, Vector128<float>  right) => Max(left, right);
-        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right) => Max(left, right);
-
-        /// <summary>
-        /// Vector min
-        /// Corresponds to vector forms of ARM64 SMIN, UMIN &amp; FMIN
-        /// </summary>
-        public static Vector64<byte>    Min(Vector64<byte>    left, Vector64<byte>    right) => Min(left, right);
-        public static Vector64<sbyte>   Min(Vector64<sbyte>   left, Vector64<sbyte>   right) => Min(left, right);
-        public static Vector64<ushort>  Min(Vector64<ushort>  left, Vector64<ushort>  right) => Min(left, right);
-        public static Vector64<short>   Min(Vector64<short>   left, Vector64<short>   right) => Min(left, right);
-        public static Vector64<uint>    Min(Vector64<uint>    left, Vector64<uint>    right) => Min(left, right);
-        public static Vector64<int>     Min(Vector64<int>     left, Vector64<int>     right) => Min(left, right);
-        public static Vector64<float>   Min(Vector64<float>   left, Vector64<float>   right) => Min(left, right);
-        public static Vector128<byte>   Min(Vector128<byte>   left, Vector128<byte>   right) => Min(left, right);
-        public static Vector128<sbyte>  Min(Vector128<sbyte>  left, Vector128<sbyte>  right) => Min(left, right);
-        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right) => Min(left, right);
-        public static Vector128<short>  Min(Vector128<short>  left, Vector128<short>  right) => Min(left, right);
-        public static Vector128<uint>   Min(Vector128<uint>   left, Vector128<uint>   right) => Min(left, right);
-        public static Vector128<int>    Min(Vector128<int>    left, Vector128<int>    right) => Min(left, right);
-        public static Vector128<float>  Min(Vector128<float>  left, Vector128<float>  right) => Min(left, right);
-        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right) => Min(left, right);
-
-        /// TBD MOV, FMOV
-
-        /// <summary>
-        /// Vector multiply
-        ///
-        /// For each element result[elem] = left[elem] * right[elem]
-        ///
-        /// Corresponds to vector forms of ARM64 MUL &amp; FMUL
-        /// </summary>
-        public static Vector64<byte>    Multiply(Vector64<byte>    left, Vector64<byte>    right) => Multiply(left, right);
-        public static Vector64<sbyte>   Multiply(Vector64<sbyte>   left, Vector64<sbyte>   right) => Multiply(left, right);
-        public static Vector64<ushort>  Multiply(Vector64<ushort>  left, Vector64<ushort>  right) => Multiply(left, right);
-        public static Vector64<short>   Multiply(Vector64<short>   left, Vector64<short>   right) => Multiply(left, right);
-        public static Vector64<uint>    Multiply(Vector64<uint>    left, Vector64<uint>    right) => Multiply(left, right);
-        public static Vector64<int>     Multiply(Vector64<int>     left, Vector64<int>     right) => Multiply(left, right);
-        public static Vector64<float>   Multiply(Vector64<float>   left, Vector64<float>   right) => Multiply(left, right);
-        public static Vector128<byte>   Multiply(Vector128<byte>   left, Vector128<byte>   right) => Multiply(left, right);
-        public static Vector128<sbyte>  Multiply(Vector128<sbyte>  left, Vector128<sbyte>  right) => Multiply(left, right);
-        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right) => Multiply(left, right);
-        public static Vector128<short>  Multiply(Vector128<short>  left, Vector128<short>  right) => Multiply(left, right);
-        public static Vector128<uint>   Multiply(Vector128<uint>   left, Vector128<uint>   right) => Multiply(left, right);
-        public static Vector128<int>    Multiply(Vector128<int>    left, Vector128<int>    right) => Multiply(left, right);
-        public static Vector128<float>  Multiply(Vector128<float>  left, Vector128<float>  right) => Multiply(left, right);
-        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) => Multiply(left, right);
-
-        /// <summary>
-        /// Vector negate
-        /// Corresponds to vector forms of ARM64 NEG &amp; FNEG
-        /// </summary>
-        public static Vector64<sbyte>   Negate(Vector64<sbyte>   value) => Negate(value);
-        public static Vector64<short>   Negate(Vector64<short>   value) => Negate(value);
-        public static Vector64<int>     Negate(Vector64<int>     value) => Negate(value);
-        public static Vector64<float>   Negate(Vector64<float>   value) => Negate(value);
-        public static Vector128<sbyte>  Negate(Vector128<sbyte>  value) => Negate(value);
-        public static Vector128<short>  Negate(Vector128<short>  value) => Negate(value);
-        public static Vector128<int>    Negate(Vector128<int>    value) => Negate(value);
-        public static Vector128<long>   Negate(Vector128<long>   value) => Negate(value);
-        public static Vector128<float>  Negate(Vector128<float>  value) => Negate(value);
-        public static Vector128<double> Negate(Vector128<double> value) => Negate(value);
-
-        /// <summary>
-        /// Vector not
-        /// Corresponds to vector forms of ARM64 NOT
-        /// </summary>
-        public static Vector64<T>  Not<T>(Vector64<T>  value) where T : struct => Not(value);
-        public static Vector128<T> Not<T>(Vector128<T> value) where T : struct => Not(value);
-
-        /// <summary>
-        /// Vector or
-        /// Corresponds to vector forms of ARM64 ORR
-        /// </summary>
-        public static Vector64<T>  Or<T>(Vector64<T>  left, Vector64<T>  right) where T : struct => Or(left, right);
-        public static Vector128<T> Or<T>(Vector128<T> left, Vector128<T> right) where T : struct => Or(left, right);
-
-        /// <summary>
-        /// Vector or not
-        /// Corresponds to vector forms of ARM64 ORN
-        /// </summary>
-        public static Vector64<T>  OrNot<T>(Vector64<T>  left, Vector64<T>  right) where T : struct => OrNot(left, right);
-        public static Vector128<T> OrNot<T>(Vector128<T> left, Vector128<T> right) where T : struct => OrNot(left, right);
-
-        /// <summary>
-        /// Vector PopCount
-        /// Corresponds to vector forms of ARM64 CNT
-        /// </summary>
-        public static Vector64<byte>    PopCount(Vector64<byte>    value) => PopCount(value);
-        public static Vector64<sbyte>   PopCount(Vector64<sbyte>   value) => PopCount(value);
-        public static Vector128<byte>   PopCount(Vector128<byte>   value) => PopCount(value);
-        public static Vector128<sbyte>  PopCount(Vector128<sbyte>  value) => PopCount(value);
-
-        /// <summary>
-        /// SetVector* Fill vector elements by replicating element value
-        ///
-        /// Corresponds to vector forms of ARM64 DUP (general), DUP (element 0), FMOV (vector, immediate)
-        /// </summary>
-        public static Vector64<T>    SetAllVector64<T>(T value)  where T : struct => SetAllVector64(value);
-        public static Vector128<T>   SetAllVector128<T>(T value) where T : struct => SetAllVector128(value);
-
-        /// <summary>
-        /// Vector square root
-        /// Corresponds to vector forms of ARM64 FRSQRT
-        /// </summary>
-        public static Vector64<float>   Sqrt(Vector64<float>   value) => Sqrt(value);
-        public static Vector128<float>  Sqrt(Vector128<float>  value) => Sqrt(value);
-        public static Vector128<double> Sqrt(Vector128<double> value) => Sqrt(value);
-
-        /// <summary>
-        /// Vector subtract
-        /// Corresponds to vector forms of ARM64 SUB &amp; FSUB
-        /// </summary>
-        public static Vector64<T>  Subtract<T>(Vector64<T>  left, Vector64<T>  right) where T : struct => Subtract(left, right);
-        public static Vector128<T> Subtract<T>(Vector128<T> left, Vector128<T> right) where T : struct => Subtract(left, right);
-
-
-        /// <summary>
-        /// Vector exclusive or
-        /// Corresponds to vector forms of ARM64 EOR
-        /// </summary>
-        public static Vector64<T>  Xor<T>(Vector64<T>  left, Vector64<T>  right) where T : struct => Xor(left, right);
-        public static Vector128<T> Xor<T>(Vector128<T> left, Vector128<T> right) where T : struct => Xor(left, right);
-    }
-}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.PlatformNotSupported.cs
new file mode 100644 (file)
index 0000000..75b0785
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.PlatformNotSupported.cs
@@ -0,0 +1,59 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#pragma warning disable IDE0060 // unused parameters
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.Arm
+{
+    /// <summary>
+    /// This class provides access to the ARM base hardware instructions via intrinsics
+    /// </summary>
+    [CLSCompliant(false)]
+    public abstract class ArmBase
+    {
+        internal ArmBase() { }
+
+        public static bool IsSupported { [Intrinsic] get => false; }
+
+        public abstract class Arm64
+        {
+            internal Arm64() { }
+
+            public static bool IsSupported { [Intrinsic] get => false; }
+
+            /// <summary>
+            ///   A64: CLS Wd, Wn
+            /// </summary>
+            public static int LeadingSignCount(int value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: CLS Xd, Xn
+            /// </summary>
+            public static int LeadingSignCount(long value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: CLZ Xd, Xn
+            /// </summary>
+            public static int LeadingZeroCount(long value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: CLZ Xd, Xn
+            /// </summary>
+            public static int LeadingZeroCount(ulong value) { throw new PlatformNotSupportedException(); }
+        }
+
+        /// <summary>
+        ///   A32: CLZ Rd, Rm
+        ///   A64: CLZ Wd, Wn
+        /// </summary>
+        public static int LeadingZeroCount(int value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A32: CLZ Rd, Rm
+        ///   A64: CLZ Wd, Wn
+        /// </summary>
+        public static int LeadingZeroCount(uint value) { throw new PlatformNotSupportedException(); }
+    }
+}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.cs
new file mode 100644 (file)
index 0000000..830959e
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.cs
@@ -0,0 +1,60 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.Arm
+{
+    /// <summary>
+    /// This class provides access to the ARM base hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class ArmBase
+    {
+        internal ArmBase() { }
+
+        public static bool IsSupported { get => IsSupported; }
+
+        [Intrinsic]
+        public abstract class Arm64
+        {
+            internal Arm64() { }
+
+            public static bool IsSupported { get => IsSupported; }
+
+            /// <summary>
+            ///   A64: CLS Wd, Wn
+            /// </summary>
+            public static int LeadingSignCount(int value) => LeadingSignCount(value);
+
+            /// <summary>
+            ///   A64: CLS Xd, Xn
+            /// </summary>
+            public static int LeadingSignCount(long value) => LeadingSignCount(value);
+
+            /// <summary>
+            ///   A64: CLZ Xd, Xn
+            /// </summary>
+            public static int LeadingZeroCount(long value) => LeadingZeroCount(value);
+
+            /// <summary>
+            ///   A64: CLZ Xd, Xn
+            /// </summary>
+            public static int LeadingZeroCount(ulong value) => LeadingZeroCount(value);
+        }
+
+        /// <summary>
+        ///   A32: CLZ Rd, Rm
+        ///   A64: CLZ Wd, Wn
+        /// </summary>
+        public static int LeadingZeroCount(int value) => LeadingZeroCount(value);
+
+        /// <summary>
+        ///   A32: CLZ Rd, Rm
+        ///   A64: CLZ Wd, Wn
+        /// </summary>
+        public static int LeadingZeroCount(uint value) => LeadingZeroCount(value);
+    }
+}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs
new file mode 100644 (file)
index 0000000..685000e
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs
@@ -0,0 +1,62 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#pragma warning disable IDE0060 // unused parameters
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.Arm
+{
+    /// <summary>
+    /// This class provides access to the ARM SHA1 hardware instructions via intrinsics
+    /// </summary>
+    [CLSCompliant(false)]
+    public abstract class Sha1 : ArmBase
+    {
+        internal Sha1() { }
+
+        public static new bool IsSupported { [Intrinsic] get => false; }
+
+        /// <summary>
+        /// uint32_t vsha1h_u32 (uint32_t hash_e)
+        ///   A32: SHA1H.32 Qd, Qm
+        ///   A64: SHA1H Sd, Sn
+        /// </summary>
+        public static uint FixedRotate(uint hash_e) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsha1cq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
+        ///   A32: SHA1C.32 Qd, Qn, Qm
+        ///   A64: SHA1C Qd, Sn, Vm.4S
+        /// </summary>
+        public static Vector128<uint> HashUpdateChoose(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsha1mq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
+        ///   A32: SHA1M.32 Qd, Qn, Qm
+        ///   A64: SHA1M Qd, Sn, Vm.4S
+        /// </summary>
+        public static Vector128<uint> HashUpdateMajority(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsha1pq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
+        ///   A32: SHA1P.32 Qd, Qn, Qm
+        ///   A64: SHA1P Qd, Sn, Vm.4S
+        /// </summary>
+        public static Vector128<uint> HashUpdateParity(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsha1su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7, uint32x4_t w8_11)
+        ///   A32: SHA1SU0.32 Qd, Qn, Qm
+        ///   A64: SHA1SU0 Vd.4S, Vn.4S, Vm.4S
+        /// </summary>
+        public static Vector128<uint> ScheduleUpdate0(Vector128<uint> w0_3, Vector128<uint> w4_7, Vector128<uint> w8_11) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsha1su1q_u32 (uint32x4_t tw0_3, uint32x4_t w12_15)
+        ///   A32: SHA1SU1.32 Qd, Qm
+        ///   A64: SHA1SU1 Vd.4S, Vn.4S
+        /// </summary>
+        public static Vector128<uint> ScheduleUpdate1(Vector128<uint> tw0_3, Vector128<uint> w12_15) { throw new PlatformNotSupportedException(); }
+    }
+}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs
new file mode 100644 (file)
index 0000000..d4d79a3
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs
@@ -0,0 +1,62 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.Arm
+{
+    /// <summary>
+    /// This class provides access to the ARM SHA1 hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class Sha1 : ArmBase
+    {
+        internal Sha1() { }
+
+        public static new bool IsSupported { get => IsSupported; }
+
+        /// <summary>
+        /// uint32_t vsha1h_u32 (uint32_t hash_e)
+        ///   A32: SHA1H.32 Qd, Qm
+        ///   A64: SHA1H Sd, Sn
+        /// </summary>
+        public static uint FixedRotate(uint hash_e) => FixedRotate(hash_e);
+
+        /// <summary>
+        /// uint32x4_t vsha1cq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
+        ///   A32: SHA1C.32 Qd, Qn, Qm
+        ///   A64: SHA1C Qd, Sn, Vm.4S
+        /// </summary>
+        public static Vector128<uint> HashUpdateChoose(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk) => HashUpdateChoose(hash_abcd, hash_e, wk);
+
+        /// <summary>
+        /// uint32x4_t vsha1mq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
+        ///   A32: SHA1M.32 Qd, Qn, Qm
+        ///   A64: SHA1M Qd, Sn, Vm.4S
+        /// </summary>
+        public static Vector128<uint> HashUpdateMajority(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk) => HashUpdateMajority(hash_abcd, hash_e, wk);
+
+        /// <summary>
+        /// uint32x4_t vsha1pq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
+        ///   A32: SHA1P.32 Qd, Qn, Qm
+        ///   A64: SHA1P Qd, Sn, Vm.4S
+        /// </summary>
+        public static Vector128<uint> HashUpdateParity(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk) => HashUpdateParity(hash_abcd, hash_e, wk);
+
+        /// <summary>
+        /// uint32x4_t vsha1su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7, uint32x4_t w8_11)
+        ///   A32: SHA1SU0.32 Qd, Qn, Qm
+        ///   A64: SHA1SU0 Vd.4S, Vn.4S, Vm.4S
+        /// </summary>
+        public static Vector128<uint> ScheduleUpdate0(Vector128<uint> w0_3, Vector128<uint> w4_7, Vector128<uint> w8_11) => ScheduleUpdate0(w0_3, w4_7, w8_11);
+
+        /// <summary>
+        /// uint32x4_t vsha1su1q_u32 (uint32x4_t tw0_3, uint32x4_t w12_15)
+        ///   A32: SHA1SU1.32 Qd, Qm
+        ///   A64: SHA1SU1 Vd.4S, Vn.4S
+        /// </summary>
+        public static Vector128<uint> ScheduleUpdate1(Vector128<uint> tw0_3, Vector128<uint> w12_15) => ScheduleUpdate1(tw0_3, w12_15);
+    }
+}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs
new file mode 100644 (file)
index 0000000..7263b56
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs
@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#pragma warning disable IDE0060 // unused parameters
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.Arm
+{
+    /// <summary>
+    /// This class provides access to the ARM SHA256 hardware instructions via intrinsics
+    /// </summary>
+    [CLSCompliant(false)]
+    public abstract class Sha256 : ArmBase
+    {
+        internal Sha256() { }
+
+        public static new bool IsSupported { [Intrinsic] get => false; }
+
+        /// <summary>
+        /// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk)
+        ///   A32: SHA256H.32 Qd, Qn, Qm
+        ///   A64: SHA256H Qd, Qn, Vm.4S
+        /// </summary>
+        public static Vector128<uint> HashUpdate1(Vector128<uint> hash_abcd, Vector128<uint> hash_efgh, Vector128<uint> wk) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsha256h2q_u32 (uint32x4_t hash_efgh, uint32x4_t hash_abcd, uint32x4_t wk)
+        ///   A32: SHA256H2.32 Qd, Qn, Qm
+        ///   A64: SHA256H2 Qd, Qn, Vm.4S
+        /// </summary>
+        public static Vector128<uint> HashUpdate2(Vector128<uint> hash_efgh, Vector128<uint> hash_abcd, Vector128<uint> wk) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsha256su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7)
+        ///   A32: SHA256SU0.32 Qd, Qm
+        ///   A64: SHA256SU0 Vd.4S, Vn.4S
+        /// </summary>
+        public static Vector128<uint> ScheduleUpdate0(Vector128<uint> w0_3, Vector128<uint> w4_7) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsha256su1q_u32 (uint32x4_t w0_3, uint32x4_t w8_11, uint32x4_t w12_15)
+        ///   A32: SHA256SU1.32 Qd, Qn, Qm
+        ///   A64: SHA256SU1 Vd.4S, Vn.4S, Vm.4S
+        /// </summary>
+        public static Vector128<uint> ScheduleUpdate1(Vector128<uint> w0_3, Vector128<uint> w8_11, Vector128<uint> w12_15) { throw new PlatformNotSupportedException(); }
+    }
+}

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs
new file mode 100644 (file)
index 0000000..e57b01c
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs
@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.Arm
+{
+    /// <summary>
+    /// This class provides access to the ARM SHA256 hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class Sha256 : ArmBase
+    {
+        internal Sha256() { }
+
+        public static new bool IsSupported { get => IsSupported; }
+
+        /// <summary>
+        /// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk)
+        ///   A32: SHA256H.32 Qd, Qn, Qm
+        ///   A64: SHA256H Qd, Qn, Vm.4S
+        /// </summary>
+        public static Vector128<uint> HashUpdate1(Vector128<uint> hash_abcd, Vector128<uint> hash_efgh, Vector128<uint> wk) => HashUpdate1(hash_abcd, hash_efgh, wk);
+
+        /// <summary>
+        /// uint32x4_t vsha256h2q_u32 (uint32x4_t hash_efgh, uint32x4_t hash_abcd, uint32x4_t wk)
+        ///   A32: SHA256H2.32 Qd, Qn, Qm
+        ///   A64: SHA256H2 Qd, Qn, Vm.4S
+        /// </summary>
+        public static Vector128<uint> HashUpdate2(Vector128<uint> hash_efgh, Vector128<uint> hash_abcd, Vector128<uint> wk) => HashUpdate2(hash_efgh, hash_abcd, wk);
+
+        /// <summary>
+        /// uint32x4_t vsha256su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7)
+        ///   A32: SHA256SU0.32 Qd, Qm
+        ///   A64: SHA256SU0 Vd.4S, Vn.4S
+        /// </summary>
+        public static Vector128<uint> ScheduleUpdate0(Vector128<uint> w0_3, Vector128<uint> w4_7) => ScheduleUpdate0(w0_3, w4_7);
+
+        /// <summary>
+        /// uint32x4_t vsha256su1q_u32 (uint32x4_t w0_3, uint32x4_t w8_11, uint32x4_t w12_15)
+        ///   A32: SHA256SU1.32 Qd, Qn, Qm
+        ///   A64: SHA256SU1 Vd.4S, Vn.4S, Vm.4S
+        /// </summary>
+        public static Vector128<uint> ScheduleUpdate1(Vector128<uint> w0_3, Vector128<uint> w8_11, Vector128<uint> w12_15) => ScheduleUpdate1(w0_3, w8_11, w12_15);
+    }
+}