diff --git a/src/mscorlib/System.Private.CoreLib.csproj b/src/mscorlib/System.Private.CoreLib.csproj index f76e0f95857e..77758fbceadc 100644 --- a/src/mscorlib/System.Private.CoreLib.csproj +++ b/src/mscorlib/System.Private.CoreLib.csproj @@ -266,12 +266,14 @@ + + + - @@ -283,6 +285,23 @@ + + + + + + + + + + + + + + + + + diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs new file mode 100644 index 000000000000..68c0a1352610 --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs @@ -0,0 +1,74 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel AES hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Aes + { + public static bool IsSupported { get { return false; } } + + /// + /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey) + /// + public static Vector128 Decrypt(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey) + /// + public static Vector128 Decrypt(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey) + /// + public static Vector128 DecryptLast(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey) + /// + public static Vector128 DecryptLast(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey) + /// + public static Vector128 Encrypt(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey) + /// + public static Vector128 Encrypt(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey) + /// + public static Vector128 EncryptLast(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey) + /// + public static Vector128 EncryptLast(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_aesimc_si128 (__m128i a) + /// + public static Vector128 InvisibleMixColumn(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_aesimc_si128 (__m128i a) + /// + public static Vector128 InvisibleMixColumn(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8) + /// + public static Vector128 KeygenAssist(Vector128 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8) + /// + public static Vector128 KeygenAssist(Vector128 value, byte control) { throw new PlatformNotSupportedException(); } + + } + +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Aes.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Aes.cs index 43aebc990cb9..b3c2a3da477d 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Aes.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Aes.cs @@ -13,61 +13,61 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Aes { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey) /// - public static Vector128 Decrypt(Vector128 value, Vector128 roundKey) { throw new NotImplementedException(); } + public static Vector128 Decrypt(Vector128 value, Vector128 roundKey) => Decrypt(value, roundKey); /// /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey) /// - public static Vector128 Decrypt(Vector128 value, Vector128 roundKey) { throw new NotImplementedException(); } + public static Vector128 Decrypt(Vector128 value, Vector128 roundKey) => Decrypt(value, roundKey); /// /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey) /// - public static Vector128 DecryptLast(Vector128 value, Vector128 roundKey) { throw new NotImplementedException(); } + public static Vector128 DecryptLast(Vector128 value, Vector128 roundKey) => DecryptLast(value, roundKey); /// /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey) /// - public static Vector128 DecryptLast(Vector128 value, Vector128 roundKey) { throw new NotImplementedException(); } + public static Vector128 DecryptLast(Vector128 value, Vector128 roundKey) => DecryptLast(value, roundKey); /// /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey) /// - public static Vector128 Encrypt(Vector128 value, Vector128 roundKey) { throw new NotImplementedException(); } + public static Vector128 Encrypt(Vector128 value, Vector128 roundKey) => Encrypt(value, roundKey); /// /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey) /// - public static Vector128 Encrypt(Vector128 value, Vector128 roundKey) { throw new NotImplementedException(); } + public static Vector128 Encrypt(Vector128 value, Vector128 roundKey) => Encrypt(value, roundKey); /// /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey) /// - public static Vector128 EncryptLast(Vector128 value, Vector128 roundKey) { throw new NotImplementedException(); } + public static Vector128 EncryptLast(Vector128 value, Vector128 roundKey) => EncryptLast(value, roundKey); /// /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey) /// - public static Vector128 EncryptLast(Vector128 value, Vector128 roundKey) { throw new NotImplementedException(); } + public static Vector128 EncryptLast(Vector128 value, Vector128 roundKey) => EncryptLast(value, roundKey); /// /// __m128i _mm_aesimc_si128 (__m128i a) /// - public static Vector128 InvisibleMixColumn(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 InvisibleMixColumn(Vector128 value) => InvisibleMixColumn(value); /// /// __m128i _mm_aesimc_si128 (__m128i a) /// - public static Vector128 InvisibleMixColumn(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 InvisibleMixColumn(Vector128 value) => InvisibleMixColumn(value); /// /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8) /// - public static Vector128 KeygenAssist(Vector128 value, byte control) { throw new NotImplementedException(); } + public static Vector128 KeygenAssist(Vector128 value, byte control) => KeygenAssist(value, control); /// /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8) /// - public static Vector128 KeygenAssist(Vector128 value, byte control) { throw new NotImplementedException(); } + public static Vector128 KeygenAssist(Vector128 value, byte control) => KeygenAssist(value, control); } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs new file mode 100644 index 000000000000..4eb9e3bb0308 --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs @@ -0,0 +1,996 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel AVX hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Avx + { + public static bool IsSupported { get { return false; } } + + /// + /// __m256 _mm256_add_ps (__m256 a, __m256 b) + /// + public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_add_pd (__m256d a, __m256d b) + /// + public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_addsub_ps (__m256 a, __m256 b) + /// + public static Vector256 AddSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_addsub_pd (__m256d a, __m256d b) + /// + public static Vector256 AddSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_and_ps (__m256 a, __m256 b) + /// + public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_and_pd (__m256d a, __m256d b) + /// + public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_andnot_ps (__m256 a, __m256 b) + /// + public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_andnot_pd (__m256d a, __m256d b) + /// + public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8) + /// + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8) + /// + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask) + /// + public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_blendv_pd (__m256d a, __m256d b, __m256d mask) + /// + public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_broadcast_ss (float const * mem_addr) + /// + public static Vector128 BroadcastElementToVector128(ref float source) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_broadcast_ss (float const * mem_addr) + /// + public static Vector256 BroadcastElementToVector256(ref float source) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_broadcast_sd (double const * mem_addr) + /// + public static Vector256 BroadcastElementToVector256(ref double source) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_broadcast_ps (__m128 const * mem_addr) + /// + public static unsafe Vector256 BroadcastVector128ToVector256(float* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_broadcast_pd (__m128d const * mem_addr) + /// + public static unsafe Vector256 BroadcastVector128ToVector256(double* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_ceil_ps (__m256 a) + /// + public static Vector256 Ceiling(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_ceil_pd (__m256d a) + /// + public static Vector256 Ceiling(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8) + /// + public static Vector128 Compare(Vector128 left, Vector128 right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8) + /// + public static Vector128 Compare(Vector128 left, Vector128 right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8) + /// + public static Vector256 Compare(Vector256 left, Vector256 right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8) + /// + public static Vector256 Compare(Vector256 left, Vector256 right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_cvtpd_epi32 (__m256d a) + /// + public static Vector128 ConvertToVector128Int(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm256_cvtpd_ps (__m256d a) + /// + public static Vector128 ConvertToVector128Float(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtps_epi32 (__m256 a) + /// + public static Vector256 ConvertToVector256Int(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_cvtepi32_ps (__m256i a) + /// + public static Vector256 ConvertToVector256Float(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_cvtps_pd (__m128 a) + /// + public static Vector256 ConvertToVector256Double(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_cvtepi32_pd (__m128i a) + /// + public static Vector256 ConvertToVector256Double(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_cvttpd_epi32 (__m256d a) + /// + public static Vector128 ConvertToVector128IntWithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvttps_epi32 (__m256 a) + /// + public static Vector256 ConvertToVector256IntWithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_div_ps (__m256 a, __m256 b) + /// + public static Vector256 Divide(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_div_pd (__m256d a, __m256d b) + /// + public static Vector256 Divide(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8) + /// + public static Vector256 DotProduct(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_moveldup_ps (__m256 a) + /// + public static Vector256 DuplicateEvenIndexed(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_movedup_pd (__m256d a) + /// + public static Vector256 DuplicateEvenIndexed(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_movehdup_ps (__m256 a) + /// + public static Vector256 DuplicateOddIndexed(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __int8 _mm256_extract_epi8 (__m256i a, const int index) + /// + public static sbyte ExtractSbyte(Vector256 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __int8 _mm256_extract_epi8 (__m256i a, const int index) + /// + public static byte ExtractByte(Vector256 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __int16 _mm256_extract_epi16 (__m256i a, const int index) + /// + public static short ExtractShort(Vector256 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __int16 _mm256_extract_epi16 (__m256i a, const int index) + /// + public static ushort ExtractUshort(Vector256 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __int32 _mm256_extract_epi32 (__m256i a, const int index) + /// + public static int ExtractInt(Vector256 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __int32 _mm256_extract_epi32 (__m256i a, const int index) + /// + public static uint ExtractUint(Vector256 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __int64 _mm256_extract_epi64 (__m256i a, const int index) + /// + public static long ExtractLong(Vector256 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __int64 _mm256_extract_epi64 (__m256i a, const int index) + /// + public static ulong ExtractUlong(Vector256 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8) + /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8) + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// + public static Vector128 ExtractVector128(Vector256 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(byte* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(sbyte* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(short* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(ushort* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(int* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(uint* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(long* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(ulong* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8) + /// + public static unsafe void ExtractVector128(float* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8) + /// + public static unsafe void ExtractVector128(double* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m256d _mm256_castpd128_pd256 (__m128d a) + /// __m256 _mm256_castps128_ps256 (__m128 a) + /// __m256i _mm256_castsi128_si256 (__m128i a) + /// + public static Vector256 ExtendToVector256(Vector128 value) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_floor_ps (__m256 a) + /// + public static Vector256 Floor(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_floor_pd (__m256d a) + /// + public static Vector256 Floor(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm256_castpd256_pd128 (__m256d a) + /// __m128 _mm256_castps256_ps128 (__m256 a) + /// __m128i _mm256_castsi256_si128 (__m256i a) + /// + public static Vector128 GetLowerHalf(Vector256 value) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_hadd_ps (__m256 a, __m256 b) + /// + public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_hadd_pd (__m256d a, __m256d b) + /// + public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_hsub_ps (__m256 a, __m256 b) + /// + public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_hsub_pd (__m256d a, __m256d b) + /// + public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_insert_epi8 (__m256i a, __int8 i, const int index) + /// + public static Vector256 InsertSbyte(Vector256 value, sbyte data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insert_epi8 (__m256i a, __int8 i, const int index) + /// + public static Vector256 InsertByte(Vector256 value, byte data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insert_epi16 (__m256i a, __int16 i, const int index) + /// + public static Vector256 InsertShort(Vector256 value, short data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insert_epi16 (__m256i a, __int16 i, const int index) + /// + public static Vector256 InsertUshort(Vector256 value, ushort data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insert_epi32 (__m256i a, __int32 i, const int index) + /// + public static Vector256 InsertInt(Vector256 value, int data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insert_epi32 (__m256i a, __int32 i, const int index) + /// + public static Vector256 InsertUint(Vector256 value, uint data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insert_epi64 (__m256i a, __int64 i, const int index) + /// + public static Vector256 InsertLong(Vector256 value, long data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insert_epi64 (__m256i a, __int64 i, const int index) + /// + public static Vector256 InsertUlong(Vector256 value, ulong data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8) + /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8) + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, sbyte* address, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, byte* address, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, short* address, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, ushort* address, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, int* address, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, uint* address, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, long* address, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, ulong* address, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, float* address, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, double* address, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 Load(sbyte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 Load(byte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 Load(short* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 Load(ushort* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 Load(int* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 Load(uint* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 Load(long* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 Load(ulong* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_loadu_ps (float const * mem_addr) + /// + public static unsafe Vector256 Load(float* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_loadu_pd (double const * mem_addr) + /// + public static unsafe Vector256 Load(double* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadAligned(sbyte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadAligned(byte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadAligned(short* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadAligned(ushort* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadAligned(int* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadAligned(uint* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadAligned(long* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadAligned(ulong* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_load_ps (float const * mem_addr) + /// + public static unsafe Vector256 LoadAligned(float* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_load_pd (double const * mem_addr) + /// + public static unsafe Vector256 LoadAligned(double* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadDqu(sbyte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadDqu(byte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadDqu(short* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadDqu(ushort* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadDqu(int* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadDqu(uint* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadDqu(long* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// + public static unsafe Vector256 LoadDqu(ulong* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask) + /// + public static unsafe Vector128 MaskLoad(float* address, Vector128 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask) + /// + public static unsafe Vector128 MaskLoad(double* address, Vector128 mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_maskload_ps (float const * mem_addr, __m256i mask) + /// + public static unsafe Vector256 MaskLoad(float* address, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_maskload_pd (double const * mem_addr, __m256i mask) + /// + public static unsafe Vector256 MaskLoad(double* address, Vector256 mask) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_maskstore_ps (float * mem_addr, __m128i mask, __m128 a) + /// + public static unsafe void MaskStore(float* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_maskstore_pd (double * mem_addr, __m128i mask, __m128d a) + /// + public static unsafe void MaskStore(double* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm256_maskstore_ps (float * mem_addr, __m256i mask, __m256 a) + /// + public static unsafe void MaskStore(float* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_maskstore_pd (double * mem_addr, __m256i mask, __m256d a) + /// + public static unsafe void MaskStore(double* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_max_ps (__m256 a, __m256 b) + /// + public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_max_pd (__m256d a, __m256d b) + /// + public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_min_ps (__m256 a, __m256 b) + /// + public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_min_pd (__m256d a, __m256d b) + /// + public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm256_movemask_ps (__m256 a) + /// + public static int MoveMask(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// int _mm256_movemask_pd (__m256d a) + /// + public static int MoveMask(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_mul_ps (__m256 a, __m256 b) + /// + public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_mul_pd (__m256d a, __m256d b) + /// + public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_or_ps (__m256 a, __m256 b) + /// + public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_or_pd (__m256d a, __m256d b) + /// + public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_permute_ps (__m128 a, int imm8) + /// + public static Vector128 Permute(Vector128 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_permute_pd (__m128d a, int imm8) + /// + public static Vector128 Permute(Vector128 value, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_permute_ps (__m256 a, int imm8) + /// + public static Vector256 Permute(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_permute_pd (__m256d a, int imm8) + /// + public static Vector256 Permute(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8) + /// + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8) + /// + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_permutevar_ps (__m128 a, __m128i b) + /// + public static Vector128 PermuteVar(Vector128 left, Vector128 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_permutevar_pd (__m128d a, __m128i b) + /// + public static Vector128 PermuteVar(Vector128 left, Vector128 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_permutevar_ps (__m256 a, __m256i b) + /// + public static Vector256 PermuteVar(Vector256 left, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_permutevar_pd (__m256d a, __m256i b) + /// + public static Vector256 PermuteVar(Vector256 left, Vector256 mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_rcp_ps (__m256 a) + /// + public static Vector256 Reciprocal(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_rsqrt_ps (__m256 a) + /// + public static Vector256 ReciprocalSqrt(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_round_ps (__m256 a, int rounding) + /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC + /// + public static Vector256 RoundToNearestInteger(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC + /// + public static Vector256 RoundToNegativeInfinity(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC + /// + public static Vector256 RoundToPositiveInfinity(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC + /// + public static Vector256 RoundToZero(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_CUR_DIRECTION + /// + public static Vector256 RoundCurrentDirection(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m256d _mm256_round_pd (__m256d a, int rounding) + /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC + /// + public static Vector256 RoundToNearestInteger(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC + /// + public static Vector256 RoundToNegativeInfinity(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC + /// + public static Vector256 RoundToPositiveInfinity(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC + /// + public static Vector256 RoundToZero(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_CUR_DIRECTION + /// + public static Vector256 RoundCurrentDirection(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_set_epi8 (char e31, char e30, char e29, char e28, char e27, char e26, char e25, char e24, char e23, char e22, char e21, char e20, char e19, char e18, char e17, char e16, char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0) + /// + public static Vector256 Set(sbyte e31, sbyte e30, sbyte e29, sbyte e28, sbyte e27, sbyte e26, sbyte e25, sbyte e24, sbyte e23, sbyte e22, sbyte e21, sbyte e20, sbyte e19, sbyte e18, sbyte e17, sbyte e16, sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_set_epi8 (char e31, char e30, char e29, char e28, char e27, char e26, char e25, char e24, char e23, char e22, char e21, char e20, char e19, char e18, char e17, char e16, char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0) + /// + public static Vector256 Set(byte e31, byte e30, byte e29, byte e28, byte e27, byte e26, byte e25, byte e24, byte e23, byte e22, byte e21, byte e20, byte e19, byte e18, byte e17, byte e16, byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_set_epi16 (short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) + /// + public static Vector256 Set(short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_set_epi16 (short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) + /// + public static Vector256 Set(ushort e15, ushort e14, ushort e13, ushort e12, ushort e11, ushort e10, ushort e9, ushort e8, ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_set_epi32 (int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) + /// + public static Vector256 Set(int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_set_epi32 (int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) + /// + public static Vector256 Set(uint e7, uint e6, uint e5, uint e4, uint e3, uint e2, uint e1, uint e0) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_set_epi64x (__int64 e3, __int64 e2, __int64 e1, __int64 e0) + /// + public static Vector256 Set(long e3, long e2, long e1, long e0) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_set_epi64x (__int64 e3, __int64 e2, __int64 e1, __int64 e0) + /// + public static Vector256 Set(ulong e3, ulong e2, ulong e1, ulong e0) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_set_ps (float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0) + /// + public static Vector256 Set(float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_set_pd (double e3, double e2, double e1, double e0) + /// + public static Vector256 Set(double e3, double e2, double e1, double e0) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_set1_epi8 (char a) + /// __m256i _mm256_set1_epi16 (short a) + /// __m256i _mm256_set1_epi32 (int a) + /// __m256i _mm256_set1_epi64x (long long a) + /// __m256 _mm256_set1_ps (float a) + /// __m256d _mm256_set1_pd (double a) + /// + public static Vector256 Set1(T value) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_set_m128 (__m128 hi, __m128 lo) + /// __m256d _mm256_set_m128d (__m128d hi, __m128d lo) + /// __m256i _mm256_set_m128i (__m128i hi, __m128i lo) + /// + public static Vector256 SetHiLo(Vector128 hi, Vector128 lo) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_setzero_si256 (void) + /// __m256 _mm256_setzero_ps (void) + /// __m256d _mm256_setzero_pd (void) + /// + public static Vector256 SetZero() where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8) + /// + public static Vector256 Shuffle(Vector256 value, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8) + /// + public static Vector256 Shuffle(Vector256 value, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_sqrt_ps (__m256 a) + /// + public static Vector256 Sqrt(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_sqrt_pd (__m256d a) + /// + public static Vector256 Sqrt(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_castpd_ps (__m256d a) + /// __m256i _mm256_castpd_si256 (__m256d a) + /// __m256d _mm256_castps_pd (__m256 a) + /// __m256i _mm256_castps_si256 (__m256 a) + /// __m256d _mm256_castsi256_pd (__m256i a) + /// __m256 _mm256_castsi256_ps (__m256i a) + /// + public static Vector256 StaticCast(Vector256 value) where T : struct where U : struct { throw new PlatformNotSupportedException(); } + + /// + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAligned(sbyte* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAligned(byte* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAligned(short* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAligned(ushort* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAligned(int* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAligned(uint* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAligned(long* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAligned(ulong* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_store_ps (float * mem_addr, __m256 a) + /// + public static unsafe void StoreAligned(float* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_store_pd (double * mem_addr, __m256d a) + /// + public static unsafe void StoreAligned(double* address, Vector256 source) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAlignedNonTemporal(byte* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAlignedNonTemporal(short* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAlignedNonTemporal(int* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAlignedNonTemporal(uint* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAlignedNonTemporal(long* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_stream_ps (float * mem_addr, __m256 a) + /// + public static unsafe void StoreAlignedNonTemporal(float* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_stream_pd (double * mem_addr, __m256d a) + /// + public static unsafe void StoreAlignedNonTemporal(double* address, Vector256 source) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void Store(sbyte* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void Store(byte* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void Store(short* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void Store(ushort* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void Store(int* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void Store(uint* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void Store(long* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// + public static unsafe void Store(ulong* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_storeu_ps (float * mem_addr, __m256 a) + /// + public static unsafe void Store(float* address, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_storeu_pd (double * mem_addr, __m256d a) + /// + public static unsafe void Store(double* address, Vector256 source) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_sub_ps (__m256 a, __m256 b) + /// + public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_sub_pd (__m256d a, __m256d b) + /// + public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_testc_ps (__m128 a, __m128 b) + /// + public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// int _mm_testc_pd (__m128d a, __m128d b) + /// + public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// int _mm256_testc_ps (__m256 a, __m256 b) + /// int _mm256_testc_pd (__m256d a, __m256d b) + /// + public static bool TestC(Vector256 left, Vector256 right) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_testnzc_ps (__m128 a, __m128 b) + /// + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// int _mm_testnzc_pd (__m128d a, __m128d b) + /// + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// int _mm256_testnzc_ps (__m256 a, __m256 b) + /// int _mm256_testnzc_pd (__m256d a, __m256d b) + /// + public static bool TestNotZAndNotC(Vector256 left, Vector256 right) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_testz_ps (__m128 a, __m128 b) + /// + public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// int _mm_testz_ps (__m128 a, __m128 b) + /// + public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// int _mm256_testz_ps (__m256 a, __m256 b) + /// int _mm256_testz_pd (__m256d a, __m256d b) + /// + public static bool TestZ(Vector256 left, Vector256 right) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_unpackhi_ps (__m256 a, __m256 b) + /// + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_unpackhi_pd (__m256d a, __m256d b) + /// + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_unpacklo_ps (__m256 a, __m256 b) + /// + public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_unpacklo_pd (__m256d a, __m256d b) + /// + public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256 _mm256_xor_ps (__m256 a, __m256 b) + /// + public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_xor_pd (__m256d a, __m256d b) + /// + public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm256_zeroall (void) + /// + public static void ZeroAll() { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_zeroupper (void) + /// + public static void ZeroUpper() { throw new PlatformNotSupportedException(); } + + /// + /// __m256d _mm256_zextpd128_pd256 (__m128d a) + /// __m256 _mm256_zextps128_ps256 (__m128 a) + /// __m256i _mm256_zextsi128_si256 (__m128i a) + /// + public static Vector256 ZeroExtendToVector256(Vector128 value) where T : struct { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.cs index ad0bfc9e1b11..1d60ca5b3eca 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.cs @@ -13,710 +13,710 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Avx { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// __m256 _mm256_add_ps (__m256 a, __m256 b) /// - public static Vector256 Add(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// /// __m256d _mm256_add_pd (__m256d a, __m256d b) /// - public static Vector256 Add(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// /// __m256 _mm256_addsub_ps (__m256 a, __m256 b) /// - public static Vector256 AddSubtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AddSubtract(Vector256 left, Vector256 right) => AddSubtract(left, right); /// /// __m256d _mm256_addsub_pd (__m256d a, __m256d b) /// - public static Vector256 AddSubtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AddSubtract(Vector256 left, Vector256 right) => AddSubtract(left, right); /// /// __m256 _mm256_and_ps (__m256 a, __m256 b) /// - public static Vector256 And(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// /// __m256d _mm256_and_pd (__m256d a, __m256d b) /// - public static Vector256 And(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// /// __m256 _mm256_andnot_ps (__m256 a, __m256 b) /// - public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// /// __m256d _mm256_andnot_pd (__m256d a, __m256d b) /// - public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// /// __m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8) /// - public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) => Blend(left, right, control); /// /// __m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8) /// - public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) => Blend(left, right, control); /// /// __m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask) /// - public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// /// __m256d _mm256_blendv_pd (__m256d a, __m256d b, __m256d mask) /// - public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// /// __m128 _mm_broadcast_ss (float const * mem_addr) /// - public static Vector128 BroadcastElementToVector128(ref float source) { throw new NotImplementedException(); } + public static Vector128 BroadcastElementToVector128(ref float source) => BroadcastElementToVector128(ref source); /// /// __m256 _mm256_broadcast_ss (float const * mem_addr) /// - public static Vector256 BroadcastElementToVector256(ref float source) { throw new NotImplementedException(); } + public static Vector256 BroadcastElementToVector256(ref float source) => BroadcastElementToVector256(ref source); /// /// __m256d _mm256_broadcast_sd (double const * mem_addr) /// - public static Vector256 BroadcastElementToVector256(ref double source) { throw new NotImplementedException(); } + public static Vector256 BroadcastElementToVector256(ref double source) => BroadcastElementToVector256(ref source); /// /// __m256 _mm256_broadcast_ps (__m128 const * mem_addr) /// - public static unsafe Vector256 BroadcastVector128ToVector256(float* address) { throw new NotImplementedException(); } + public static unsafe Vector256 BroadcastVector128ToVector256(float* address) => BroadcastVector128ToVector256(address); /// /// __m256d _mm256_broadcast_pd (__m128d const * mem_addr) /// - public static unsafe Vector256 BroadcastVector128ToVector256(double* address) { throw new NotImplementedException(); } + public static unsafe Vector256 BroadcastVector128ToVector256(double* address) => BroadcastVector128ToVector256(address); /// /// __m256 _mm256_ceil_ps (__m256 a) /// - public static Vector256 Ceiling(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 Ceiling(Vector256 value) => Ceiling(value); /// /// __m256d _mm256_ceil_pd (__m256d a) /// - public static Vector256 Ceiling(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 Ceiling(Vector256 value) => Ceiling(value); /// /// __m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8) /// - public static Vector128 Compare(Vector128 left, Vector128 right, FloatComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 Compare(Vector128 left, Vector128 right, FloatComparisonMode mode) => Compare(left, right, mode); /// /// __m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8) /// - public static Vector128 Compare(Vector128 left, Vector128 right, FloatComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 Compare(Vector128 left, Vector128 right, FloatComparisonMode mode) => Compare(left, right, mode); /// /// __m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8) /// - public static Vector256 Compare(Vector256 left, Vector256 right, FloatComparisonMode mode) { throw new NotImplementedException(); } + public static Vector256 Compare(Vector256 left, Vector256 right, FloatComparisonMode mode) => Compare(left, right, mode); /// /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8) /// - public static Vector256 Compare(Vector256 left, Vector256 right, FloatComparisonMode mode) { throw new NotImplementedException(); } + public static Vector256 Compare(Vector256 left, Vector256 right, FloatComparisonMode mode) => Compare(left, right, mode); /// /// __m128i _mm256_cvtpd_epi32 (__m256d a) /// - public static Vector128 ConvertToVector128Int(Vector256 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToVector128Int(Vector256 value) => ConvertToVector128Int(value); /// /// __m128 _mm256_cvtpd_ps (__m256d a) /// - public static Vector128 ConvertToVector128Float(Vector256 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToVector128Float(Vector256 value) => ConvertToVector128Float(value); /// /// __m256i _mm256_cvtps_epi32 (__m256 a) /// - public static Vector256 ConvertToVector256Int(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256Int(Vector256 value) => ConvertToVector256Int(value); /// /// __m256 _mm256_cvtepi32_ps (__m256i a) /// - public static Vector256 ConvertToVector256Float(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256Float(Vector256 value) => ConvertToVector256Float(value); /// /// __m256d _mm256_cvtps_pd (__m128 a) /// - public static Vector256 ConvertToVector256Double(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256Double(Vector256 value) => ConvertToVector256Double(value); /// /// __m256d _mm256_cvtepi32_pd (__m128i a) /// - public static Vector256 ConvertToVector256Double(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256Double(Vector256 value) => ConvertToVector256Double(value); /// /// __m128i _mm256_cvttpd_epi32 (__m256d a) /// - public static Vector128 ConvertToVector128IntWithTruncation(Vector256 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToVector128IntWithTruncation(Vector256 value) => ConvertToVector128IntWithTruncation(value); /// /// __m256i _mm256_cvttps_epi32 (__m256 a) /// - public static Vector256 ConvertToVector256IntWithTruncation(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256IntWithTruncation(Vector256 value) => ConvertToVector256IntWithTruncation(value); /// /// __m256 _mm256_div_ps (__m256 a, __m256 b) /// - public static Vector256 Divide(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Divide(Vector256 left, Vector256 right) => Divide(left, right); /// /// __m256d _mm256_div_pd (__m256d a, __m256d b) /// - public static Vector256 Divide(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Divide(Vector256 left, Vector256 right) => Divide(left, right); /// /// __m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8) /// - public static Vector256 DotProduct(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 DotProduct(Vector256 left, Vector256 right, byte control) => DotProduct(left, right, control); /// /// __m256 _mm256_moveldup_ps (__m256 a) /// - public static Vector256 DuplicateEvenIndexed(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 DuplicateEvenIndexed(Vector256 value) => DuplicateEvenIndexed(value); /// /// __m256d _mm256_movedup_pd (__m256d a) /// - public static Vector256 DuplicateEvenIndexed(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 DuplicateEvenIndexed(Vector256 value) => DuplicateEvenIndexed(value); /// /// __m256 _mm256_movehdup_ps (__m256 a) /// - public static Vector256 DuplicateOddIndexed(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 DuplicateOddIndexed(Vector256 value) => DuplicateOddIndexed(value); /// /// __int8 _mm256_extract_epi8 (__m256i a, const int index) /// - public static sbyte ExtractSbyte(Vector256 value, byte index) where T : struct { throw new NotImplementedException(); } + public static sbyte ExtractSbyte(Vector256 value, byte index) where T : struct => ExtractSbyte(value, index); /// /// __int8 _mm256_extract_epi8 (__m256i a, const int index) /// - public static byte ExtractByte(Vector256 value, byte index) where T : struct { throw new NotImplementedException(); } + public static byte ExtractByte(Vector256 value, byte index) where T : struct => ExtractByte(value, index); /// /// __int16 _mm256_extract_epi16 (__m256i a, const int index) /// - public static short ExtractShort(Vector256 value, byte index) where T : struct { throw new NotImplementedException(); } + public static short ExtractShort(Vector256 value, byte index) where T : struct => ExtractShort(value, index); /// /// __int16 _mm256_extract_epi16 (__m256i a, const int index) /// - public static ushort ExtractUshort(Vector256 value, byte index) where T : struct { throw new NotImplementedException(); } + public static ushort ExtractUshort(Vector256 value, byte index) where T : struct => ExtractUshort(value, index); /// /// __int32 _mm256_extract_epi32 (__m256i a, const int index) /// - public static int ExtractInt(Vector256 value, byte index) where T : struct { throw new NotImplementedException(); } + public static int ExtractInt(Vector256 value, byte index) where T : struct => ExtractInt(value, index); /// /// __int32 _mm256_extract_epi32 (__m256i a, const int index) /// - public static uint ExtractUint(Vector256 value, byte index) where T : struct { throw new NotImplementedException(); } + public static uint ExtractUint(Vector256 value, byte index) where T : struct => ExtractUint(value, index); /// /// __int64 _mm256_extract_epi64 (__m256i a, const int index) /// - public static long ExtractLong(Vector256 value, byte index) where T : struct { throw new NotImplementedException(); } + public static long ExtractLong(Vector256 value, byte index) where T : struct => ExtractLong(value, index); /// /// __int64 _mm256_extract_epi64 (__m256i a, const int index) /// - public static ulong ExtractUlong(Vector256 value, byte index) where T : struct { throw new NotImplementedException(); } + public static ulong ExtractUlong(Vector256 value, byte index) where T : struct => ExtractUlong(value, index); /// /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8) /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8) /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) /// - public static Vector128 ExtractVector128(Vector256 value, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector128 ExtractVector128(Vector256 value, byte index) where T : struct => ExtractVector128(value, index); /// /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(byte* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(byte* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(sbyte* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(sbyte* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(short* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(short* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(ushort* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(ushort* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(int* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(int* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(uint* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(uint* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(long* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(long* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(ulong* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(ulong* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8) /// - public static unsafe void ExtractVector128(float* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(float* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8) /// - public static unsafe void ExtractVector128(double* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(double* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m256d _mm256_castpd128_pd256 (__m128d a) /// __m256 _mm256_castps128_ps256 (__m128 a) /// __m256i _mm256_castsi128_si256 (__m128i a) /// - public static Vector256 ExtendToVector256(Vector128 value) where T : struct { throw new NotImplementedException(); } + public static Vector256 ExtendToVector256(Vector128 value) where T : struct => ExtendToVector256(value); /// /// __m256 _mm256_floor_ps (__m256 a) /// - public static Vector256 Floor(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 Floor(Vector256 value) => Floor(value); /// /// __m256d _mm256_floor_pd (__m256d a) /// - public static Vector256 Floor(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 Floor(Vector256 value) => Floor(value); /// /// __m128d _mm256_castpd256_pd128 (__m256d a) /// __m128 _mm256_castps256_ps128 (__m256 a) /// __m128i _mm256_castsi256_si128 (__m256i a) /// - public static Vector128 GetLowerHalf(Vector256 value) where T : struct { throw new NotImplementedException(); } + public static Vector128 GetLowerHalf(Vector256 value) where T : struct => GetLowerHalf(value); /// /// __m256 _mm256_hadd_ps (__m256 a, __m256 b) /// - public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) => HorizontalAdd(left, right); /// /// __m256d _mm256_hadd_pd (__m256d a, __m256d b) /// - public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) => HorizontalAdd(left, right); /// /// __m256 _mm256_hsub_ps (__m256 a, __m256 b) /// - public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) => HorizontalSubtract(left, right); /// /// __m256d _mm256_hsub_pd (__m256d a, __m256d b) /// - public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) => HorizontalSubtract(left, right); /// /// __m256i _mm256_insert_epi8 (__m256i a, __int8 i, const int index) /// - public static Vector256 InsertSbyte(Vector256 value, sbyte data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector256 InsertSbyte(Vector256 value, sbyte data, byte index) where T : struct => InsertSbyte(value, data, index); /// /// __m256i _mm256_insert_epi8 (__m256i a, __int8 i, const int index) /// - public static Vector256 InsertByte(Vector256 value, byte data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector256 InsertByte(Vector256 value, byte data, byte index) where T : struct => InsertByte(value, data, index); /// /// __m256i _mm256_insert_epi16 (__m256i a, __int16 i, const int index) /// - public static Vector256 InsertShort(Vector256 value, short data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector256 InsertShort(Vector256 value, short data, byte index) where T : struct => InsertShort(value, data, index); /// /// __m256i _mm256_insert_epi16 (__m256i a, __int16 i, const int index) /// - public static Vector256 InsertUshort(Vector256 value, ushort data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector256 InsertUshort(Vector256 value, ushort data, byte index) where T : struct => InsertUshort(value, data, index); /// /// __m256i _mm256_insert_epi32 (__m256i a, __int32 i, const int index) /// - public static Vector256 InsertInt(Vector256 value, int data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector256 InsertInt(Vector256 value, int data, byte index) where T : struct => InsertInt(value, data, index); /// /// __m256i _mm256_insert_epi32 (__m256i a, __int32 i, const int index) /// - public static Vector256 InsertUint(Vector256 value, uint data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector256 InsertUint(Vector256 value, uint data, byte index) where T : struct => InsertUint(value, data, index); /// /// __m256i _mm256_insert_epi64 (__m256i a, __int64 i, const int index) /// - public static Vector256 InsertLong(Vector256 value, long data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector256 InsertLong(Vector256 value, long data, byte index) where T : struct => InsertLong(value, data, index); /// /// __m256i _mm256_insert_epi64 (__m256i a, __int64 i, const int index) /// - public static Vector256 InsertUlong(Vector256 value, ulong data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector256 InsertUlong(Vector256 value, ulong data, byte index) where T : struct => InsertUlong(value, data, index); /// /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8) /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8) /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) /// - public static Vector256 Insert(Vector256 value, Vector128 data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) where T : struct => Insert(value, data, index); /// /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, sbyte* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, sbyte* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, byte* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, byte* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, short* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, short* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, ushort* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, ushort* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, int* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, int* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, uint* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, uint* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, long* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, long* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, ulong* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, ulong* address) => Insert(value, address); /// /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, float* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, float* address) => Insert(value, address); /// /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, double* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, double* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 Load(sbyte* address) { throw new NotImplementedException(); } + public static unsafe Vector256 Load(sbyte* address) => Load(address); /// /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 Load(byte* address) { throw new NotImplementedException(); } + public static unsafe Vector256 Load(byte* address) => Load(address); /// /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 Load(short* address) { throw new NotImplementedException(); } + public static unsafe Vector256 Load(short* address) => Load(address); /// /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 Load(ushort* address) { throw new NotImplementedException(); } + public static unsafe Vector256 Load(ushort* address) => Load(address); /// /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 Load(int* address) { throw new NotImplementedException(); } + public static unsafe Vector256 Load(int* address) => Load(address); /// /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 Load(uint* address) { throw new NotImplementedException(); } + public static unsafe Vector256 Load(uint* address) => Load(address); /// /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 Load(long* address) { throw new NotImplementedException(); } + public static unsafe Vector256 Load(long* address) => Load(address); /// /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 Load(ulong* address) { throw new NotImplementedException(); } + public static unsafe Vector256 Load(ulong* address) => Load(address); /// /// __m256 _mm256_loadu_ps (float const * mem_addr) /// - public static unsafe Vector256 Load(float* address) { throw new NotImplementedException(); } + public static unsafe Vector256 Load(float* address) => Load(address); /// /// __m256d _mm256_loadu_pd (double const * mem_addr) /// - public static unsafe Vector256 Load(double* address) { throw new NotImplementedException(); } + public static unsafe Vector256 Load(double* address) => Load(address); /// /// __m256i _mm256_load_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadAligned(sbyte* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadAligned(sbyte* address) => LoadAligned(address); /// /// __m256i _mm256_load_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadAligned(byte* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadAligned(byte* address) => LoadAligned(address); /// /// __m256i _mm256_load_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadAligned(short* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadAligned(short* address) => LoadAligned(address); /// /// __m256i _mm256_load_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadAligned(ushort* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadAligned(ushort* address) => LoadAligned(address); /// /// __m256i _mm256_load_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadAligned(int* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadAligned(int* address) => LoadAligned(address); /// /// __m256i _mm256_load_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadAligned(uint* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadAligned(uint* address) => LoadAligned(address); /// /// __m256i _mm256_load_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadAligned(long* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadAligned(long* address) => LoadAligned(address); /// /// __m256i _mm256_load_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadAligned(ulong* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadAligned(ulong* address) => LoadAligned(address); /// /// __m256 _mm256_load_ps (float const * mem_addr) /// - public static unsafe Vector256 LoadAligned(float* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadAligned(float* address) => LoadAligned(address); /// /// __m256d _mm256_load_pd (double const * mem_addr) /// - public static unsafe Vector256 LoadAligned(double* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadAligned(double* address) => LoadAligned(address); /// /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadDqu(sbyte* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadDqu(sbyte* address) => LoadDqu(address); /// /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadDqu(byte* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadDqu(byte* address) => LoadDqu(address); /// /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadDqu(short* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadDqu(short* address) => LoadDqu(address); /// /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadDqu(ushort* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadDqu(ushort* address) => LoadDqu(address); /// /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadDqu(int* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadDqu(int* address) => LoadDqu(address); /// /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadDqu(uint* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadDqu(uint* address) => LoadDqu(address); /// /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadDqu(long* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadDqu(long* address) => LoadDqu(address); /// /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) /// - public static unsafe Vector256 LoadDqu(ulong* address) { throw new NotImplementedException(); } + public static unsafe Vector256 LoadDqu(ulong* address) => LoadDqu(address); /// /// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask) /// - public static unsafe Vector128 MaskLoad(float* address, Vector128 mask) { throw new NotImplementedException(); } + public static unsafe Vector128 MaskLoad(float* address, Vector128 mask) => MaskLoad(address, mask); /// /// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask) /// - public static unsafe Vector128 MaskLoad(double* address, Vector128 mask) { throw new NotImplementedException(); } + public static unsafe Vector128 MaskLoad(double* address, Vector128 mask) => MaskLoad(address, mask); /// /// __m256 _mm256_maskload_ps (float const * mem_addr, __m256i mask) /// - public static unsafe Vector256 MaskLoad(float* address, Vector256 mask) { throw new NotImplementedException(); } + public static unsafe Vector256 MaskLoad(float* address, Vector256 mask) => MaskLoad(address, mask); /// /// __m256d _mm256_maskload_pd (double const * mem_addr, __m256i mask) /// - public static unsafe Vector256 MaskLoad(double* address, Vector256 mask) { throw new NotImplementedException(); } + public static unsafe Vector256 MaskLoad(double* address, Vector256 mask) => MaskLoad(address, mask); /// /// void _mm_maskstore_ps (float * mem_addr, __m128i mask, __m128 a) /// - public static unsafe void MaskStore(float* address, Vector128 mask, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(float* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// /// void _mm_maskstore_pd (double * mem_addr, __m128i mask, __m128d a) /// - public static unsafe void MaskStore(double* address, Vector128 mask, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(double* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// /// void _mm256_maskstore_ps (float * mem_addr, __m256i mask, __m256 a) /// - public static unsafe void MaskStore(float* address, Vector256 mask, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(float* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// /// void _mm256_maskstore_pd (double * mem_addr, __m256i mask, __m256d a) /// - public static unsafe void MaskStore(double* address, Vector256 mask, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(double* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// /// __m256 _mm256_max_ps (__m256 a, __m256 b) /// - public static Vector256 Max(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// /// __m256d _mm256_max_pd (__m256d a, __m256d b) /// - public static Vector256 Max(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// /// __m256 _mm256_min_ps (__m256 a, __m256 b) /// - public static Vector256 Min(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// /// __m256d _mm256_min_pd (__m256d a, __m256d b) /// - public static Vector256 Min(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// /// int _mm256_movemask_ps (__m256 a) /// - public static int MoveMask(Vector256 value) { throw new NotImplementedException(); } + public static int MoveMask(Vector256 value) => MoveMask(value); /// /// int _mm256_movemask_pd (__m256d a) /// - public static int MoveMask(Vector256 value) { throw new NotImplementedException(); } + public static int MoveMask(Vector256 value) => MoveMask(value); /// /// __m256 _mm256_mul_ps (__m256 a, __m256 b) /// - public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Multiply(Vector256 left, Vector256 right) => Multiply(left, right); /// /// __m256d _mm256_mul_pd (__m256d a, __m256d b) /// - public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Multiply(Vector256 left, Vector256 right) => Multiply(left, right); /// /// __m256 _mm256_or_ps (__m256 a, __m256 b) /// - public static Vector256 Or(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// /// __m256d _mm256_or_pd (__m256d a, __m256d b) /// - public static Vector256 Or(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// /// __m128 _mm_permute_ps (__m128 a, int imm8) /// - public static Vector128 Permute(Vector128 value, byte control) { throw new NotImplementedException(); } + public static Vector128 Permute(Vector128 value, byte control) => Permute(value, control); /// /// __m128d _mm_permute_pd (__m128d a, int imm8) /// - public static Vector128 Permute(Vector128 value, byte control) { throw new NotImplementedException(); } + public static Vector128 Permute(Vector128 value, byte control) => Permute(value, control); /// /// __m256 _mm256_permute_ps (__m256 a, int imm8) /// - public static Vector256 Permute(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute(Vector256 value, byte control) => Permute(value, control); /// /// __m256d _mm256_permute_pd (__m256d a, int imm8) /// - public static Vector256 Permute(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute(Vector256 value, byte control) => Permute(value, control); /// /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8) /// - public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) => Permute2x128(left, right, control); /// /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8) /// - public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) => Permute2x128(left, right, control); /// /// __m128 _mm_permutevar_ps (__m128 a, __m128i b) /// - public static Vector128 PermuteVar(Vector128 left, Vector128 mask) { throw new NotImplementedException(); } + public static Vector128 PermuteVar(Vector128 left, Vector128 mask) => PermuteVar(left, mask); /// /// __m128d _mm_permutevar_pd (__m128d a, __m128i b) /// - public static Vector128 PermuteVar(Vector128 left, Vector128 mask) { throw new NotImplementedException(); } + public static Vector128 PermuteVar(Vector128 left, Vector128 mask) => PermuteVar(left, mask); /// /// __m256 _mm256_permutevar_ps (__m256 a, __m256i b) /// - public static Vector256 PermuteVar(Vector256 left, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 PermuteVar(Vector256 left, Vector256 mask) => PermuteVar(left, mask); /// /// __m256d _mm256_permutevar_pd (__m256d a, __m256i b) /// - public static Vector256 PermuteVar(Vector256 left, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 PermuteVar(Vector256 left, Vector256 mask) => PermuteVar(left, mask); /// /// __m256 _mm256_rcp_ps (__m256 a) /// - public static Vector256 Reciprocal(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 Reciprocal(Vector256 value) => Reciprocal(value); /// /// __m256 _mm256_rsqrt_ps (__m256 a) /// - public static Vector256 ReciprocalSqrt(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 ReciprocalSqrt(Vector256 value) => ReciprocalSqrt(value); /// /// __m256 _mm256_round_ps (__m256 a, int rounding) /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC /// - public static Vector256 RoundToNearestInteger(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 RoundToNearestInteger(Vector256 value) => RoundToNearestInteger(value); /// /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC /// - public static Vector256 RoundToNegativeInfinity(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 RoundToNegativeInfinity(Vector256 value) => RoundToNegativeInfinity(value); /// /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC /// - public static Vector256 RoundToPositiveInfinity(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 RoundToPositiveInfinity(Vector256 value) => RoundToPositiveInfinity(value); /// /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC /// - public static Vector256 RoundToZero(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 RoundToZero(Vector256 value) => RoundToZero(value); /// /// _MM_FROUND_CUR_DIRECTION /// - public static Vector256 RoundCurrentDirection(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 RoundCurrentDirection(Vector256 value) => RoundCurrentDirection(value); /// /// __m256d _mm256_round_pd (__m256d a, int rounding) /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC /// - public static Vector256 RoundToNearestInteger(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 RoundToNearestInteger(Vector256 value) => RoundToNearestInteger(value); /// /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC /// - public static Vector256 RoundToNegativeInfinity(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 RoundToNegativeInfinity(Vector256 value) => RoundToNegativeInfinity(value); /// /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC /// - public static Vector256 RoundToPositiveInfinity(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 RoundToPositiveInfinity(Vector256 value) => RoundToPositiveInfinity(value); /// /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC /// - public static Vector256 RoundToZero(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 RoundToZero(Vector256 value) => RoundToZero(value); /// /// _MM_FROUND_CUR_DIRECTION /// - public static Vector256 RoundCurrentDirection(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 RoundCurrentDirection(Vector256 value) => RoundCurrentDirection(value); /// /// __m256i _mm256_set_epi8 (char e31, char e30, char e29, char e28, char e27, char e26, char e25, char e24, char e23, char e22, char e21, char e20, char e19, char e18, char e17, char e16, char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0) /// - public static Vector256 Set(sbyte e31, sbyte e30, sbyte e29, sbyte e28, sbyte e27, sbyte e26, sbyte e25, sbyte e24, sbyte e23, sbyte e22, sbyte e21, sbyte e20, sbyte e19, sbyte e18, sbyte e17, sbyte e16, sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) { throw new NotImplementedException(); } + public static Vector256 Set(sbyte e31, sbyte e30, sbyte e29, sbyte e28, sbyte e27, sbyte e26, sbyte e25, sbyte e24, sbyte e23, sbyte e22, sbyte e21, sbyte e20, sbyte e19, sbyte e18, sbyte e17, sbyte e16, sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) => Set(e31, e30, e29, e28, e27, e26, e25, e24, e23, e22, e21, e20, e19, e18, e17, e16, e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0); /// /// __m256i _mm256_set_epi8 (char e31, char e30, char e29, char e28, char e27, char e26, char e25, char e24, char e23, char e22, char e21, char e20, char e19, char e18, char e17, char e16, char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0) /// - public static Vector256 Set(byte e31, byte e30, byte e29, byte e28, byte e27, byte e26, byte e25, byte e24, byte e23, byte e22, byte e21, byte e20, byte e19, byte e18, byte e17, byte e16, byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) { throw new NotImplementedException(); } + public static Vector256 Set(byte e31, byte e30, byte e29, byte e28, byte e27, byte e26, byte e25, byte e24, byte e23, byte e22, byte e21, byte e20, byte e19, byte e18, byte e17, byte e16, byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) => Set(e31, e30, e29, e28, e27, e26, e25, e24, e23, e22, e21, e20, e19, e18, e17, e16, e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0); /// /// __m256i _mm256_set_epi16 (short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) /// - public static Vector256 Set(short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) { throw new NotImplementedException(); } + public static Vector256 Set(short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) => Set(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0); /// /// __m256i _mm256_set_epi16 (short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) /// - public static Vector256 Set(ushort e15, ushort e14, ushort e13, ushort e12, ushort e11, ushort e10, ushort e9, ushort e8, ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) { throw new NotImplementedException(); } + public static Vector256 Set(ushort e15, ushort e14, ushort e13, ushort e12, ushort e11, ushort e10, ushort e9, ushort e8, ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) => Set(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0); /// /// __m256i _mm256_set_epi32 (int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) /// - public static Vector256 Set(int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) { throw new NotImplementedException(); } + public static Vector256 Set(int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) => Set(e7, e6, e5, e4, e3, e2, e1, e0); /// /// __m256i _mm256_set_epi32 (int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) /// - public static Vector256 Set(uint e7, uint e6, uint e5, uint e4, uint e3, uint e2, uint e1, uint e0) { throw new NotImplementedException(); } + public static Vector256 Set(uint e7, uint e6, uint e5, uint e4, uint e3, uint e2, uint e1, uint e0) => Set(e7, e6, e5, e4, e3, e2, e1, e0); /// /// __m256i _mm256_set_epi64x (__int64 e3, __int64 e2, __int64 e1, __int64 e0) /// - public static Vector256 Set(long e3, long e2, long e1, long e0) { throw new NotImplementedException(); } + public static Vector256 Set(long e3, long e2, long e1, long e0) => Set(e3, e2, e1, e0); /// /// __m256i _mm256_set_epi64x (__int64 e3, __int64 e2, __int64 e1, __int64 e0) /// - public static Vector256 Set(ulong e3, ulong e2, ulong e1, ulong e0) { throw new NotImplementedException(); } + public static Vector256 Set(ulong e3, ulong e2, ulong e1, ulong e0) => Set(e3, e2, e1, e0); /// /// __m256 _mm256_set_ps (float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0) /// - public static Vector256 Set(float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0) { throw new NotImplementedException(); } + public static Vector256 Set(float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0) => Set(e7, e6, e5, e4, e3, e2, e1, e0); /// /// __m256d _mm256_set_pd (double e3, double e2, double e1, double e0) /// - public static Vector256 Set(double e3, double e2, double e1, double e0) { throw new NotImplementedException(); } + public static Vector256 Set(double e3, double e2, double e1, double e0) => Set(e3, e2, e1, e0); /// /// __m256i _mm256_set1_epi8 (char a) @@ -726,39 +726,39 @@ public static class Avx /// __m256 _mm256_set1_ps (float a) /// __m256d _mm256_set1_pd (double a) /// - public static Vector256 Set1(T value) where T : struct { throw new NotImplementedException(); } + public static Vector256 Set1(T value) where T : struct => Set1(value); /// /// __m256 _mm256_set_m128 (__m128 hi, __m128 lo) /// __m256d _mm256_set_m128d (__m128d hi, __m128d lo) /// __m256i _mm256_set_m128i (__m128i hi, __m128i lo) /// - public static Vector256 SetHiLo(Vector128 hi, Vector128 lo) where T : struct { throw new NotImplementedException(); } + public static Vector256 SetHiLo(Vector128 hi, Vector128 lo) where T : struct => SetHiLo(hi, lo); /// /// __m256i _mm256_setzero_si256 (void) /// __m256 _mm256_setzero_ps (void) /// __m256d _mm256_setzero_pd (void) /// - public static Vector256 SetZero() where T : struct { throw new NotImplementedException(); } + public static Vector256 SetZero() where T : struct => SetZero(); /// /// __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8) /// - public static Vector256 Shuffle(Vector256 value, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Shuffle(Vector256 value, Vector256 right, byte control) => Shuffle(value, right, control); /// /// __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8) /// - public static Vector256 Shuffle(Vector256 value, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Shuffle(Vector256 value, Vector256 right, byte control) => Shuffle(value, right, control); /// /// __m256 _mm256_sqrt_ps (__m256 a) /// - public static Vector256 Sqrt(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 Sqrt(Vector256 value) => Sqrt(value); /// /// __m256d _mm256_sqrt_pd (__m256d a) /// - public static Vector256 Sqrt(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 Sqrt(Vector256 value) => Sqrt(value); /// /// __m256 _mm256_castpd_ps (__m256d a) @@ -768,229 +768,229 @@ public static class Avx /// __m256d _mm256_castsi256_pd (__m256i a) /// __m256 _mm256_castsi256_ps (__m256i a) /// - public static Vector256 StaticCast(Vector256 value) where T : struct where U : struct { throw new NotImplementedException(); } + public static Vector256 StaticCast(Vector256 value) where T : struct where U : struct => StaticCast(value); /// /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAligned(sbyte* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(sbyte* address, Vector256 source) => StoreAligned(address, source); /// /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAligned(byte* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(byte* address, Vector256 source) => StoreAligned(address, source); /// /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAligned(short* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(short* address, Vector256 source) => StoreAligned(address, source); /// /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAligned(ushort* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(ushort* address, Vector256 source) => StoreAligned(address, source); /// /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAligned(int* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(int* address, Vector256 source) => StoreAligned(address, source); /// /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAligned(uint* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(uint* address, Vector256 source) => StoreAligned(address, source); /// /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAligned(long* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(long* address, Vector256 source) => StoreAligned(address, source); /// /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAligned(ulong* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(ulong* address, Vector256 source) => StoreAligned(address, source); /// /// void _mm256_store_ps (float * mem_addr, __m256 a) /// - public static unsafe void StoreAligned(float* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(float* address, Vector256 source) => StoreAligned(address, source); /// /// void _mm256_store_pd (double * mem_addr, __m256d a) /// - public static unsafe void StoreAligned(double* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(double* address, Vector256 source) => StoreAligned(address, source); /// /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAlignedNonTemporal(byte* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(byte* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAlignedNonTemporal(short* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(short* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAlignedNonTemporal(int* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(int* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAlignedNonTemporal(uint* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(uint* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAlignedNonTemporal(long* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(long* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm256_stream_ps (float * mem_addr, __m256 a) /// - public static unsafe void StoreAlignedNonTemporal(float* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(float* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm256_stream_pd (double * mem_addr, __m256d a) /// - public static unsafe void StoreAlignedNonTemporal(double* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(double* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void Store(sbyte* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void Store(sbyte* address, Vector256 source) => Store(address, source); /// /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void Store(byte* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void Store(byte* address, Vector256 source) => Store(address, source); /// /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void Store(short* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void Store(short* address, Vector256 source) => Store(address, source); /// /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void Store(ushort* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void Store(ushort* address, Vector256 source) => Store(address, source); /// /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void Store(int* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void Store(int* address, Vector256 source) => Store(address, source); /// /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void Store(uint* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void Store(uint* address, Vector256 source) => Store(address, source); /// /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void Store(long* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void Store(long* address, Vector256 source) => Store(address, source); /// /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) /// - public static unsafe void Store(ulong* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void Store(ulong* address, Vector256 source) => Store(address, source); /// /// void _mm256_storeu_ps (float * mem_addr, __m256 a) /// - public static unsafe void Store(float* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void Store(float* address, Vector256 source) => Store(address, source); /// /// void _mm256_storeu_pd (double * mem_addr, __m256d a) /// - public static unsafe void Store(double* address, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void Store(double* address, Vector256 source) => Store(address, source); /// /// __m256 _mm256_sub_ps (__m256 a, __m256 b) /// - public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// /// __m256d _mm256_sub_pd (__m256d a, __m256d b) /// - public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// /// int _mm_testc_ps (__m128 a, __m128 b) /// - public static bool TestC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// /// int _mm_testc_pd (__m128d a, __m128d b) /// - public static bool TestC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// /// int _mm256_testc_si256 (__m256i a, __m256i b) /// int _mm256_testc_ps (__m256 a, __m256 b) /// int _mm256_testc_pd (__m256d a, __m256d b) /// - public static bool TestC(Vector256 left, Vector256 right) where T : struct { throw new NotImplementedException(); } + public static bool TestC(Vector256 left, Vector256 right) where T : struct => TestC(left, right); /// /// int _mm_testnzc_ps (__m128 a, __m128 b) /// - public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// /// int _mm_testnzc_pd (__m128d a, __m128d b) /// - public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// /// int _mm256_testnzc_si256 (__m256i a, __m256i b) /// int _mm256_testnzc_ps (__m256 a, __m256 b) /// int _mm256_testnzc_pd (__m256d a, __m256d b) /// - public static bool TestNotZAndNotC(Vector256 left, Vector256 right) where T : struct { throw new NotImplementedException(); } + public static bool TestNotZAndNotC(Vector256 left, Vector256 right) where T : struct => TestNotZAndNotC(left, right); /// /// int _mm_testz_ps (__m128 a, __m128 b) /// - public static bool TestZ(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// /// int _mm_testz_ps (__m128 a, __m128 b) /// - public static bool TestZ(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// /// int _mm256_testz_si256 (__m256i a, __m256i b) /// int _mm256_testz_ps (__m256 a, __m256 b) /// int _mm256_testz_pd (__m256d a, __m256d b) /// - public static bool TestZ(Vector256 left, Vector256 right) where T : struct { throw new NotImplementedException(); } + public static bool TestZ(Vector256 left, Vector256 right) where T : struct => TestZ(left, right); /// /// __m256 _mm256_unpackhi_ps (__m256 a, __m256 b) /// - public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// /// __m256d _mm256_unpackhi_pd (__m256d a, __m256d b) /// - public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// /// __m256 _mm256_unpacklo_ps (__m256 a, __m256 b) /// - public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// /// __m256d _mm256_unpacklo_pd (__m256d a, __m256d b) /// - public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// /// __m256 _mm256_xor_ps (__m256 a, __m256 b) /// - public static Vector256 Xor(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// /// __m256d _mm256_xor_pd (__m256d a, __m256d b) /// - public static Vector256 Xor(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// /// void _mm256_zeroall (void) /// - public static void ZeroAll() { throw new NotImplementedException(); } + public static void ZeroAll() => ZeroAll(); /// /// void _mm256_zeroupper (void) /// - public static void ZeroUpper() { throw new NotImplementedException(); } + public static void ZeroUpper() => ZeroUpper(); /// /// __m256d _mm256_zextpd128_pd256 (__m128d a) /// __m256 _mm256_zextps128_ps256 (__m128 a) /// __m256i _mm256_zextsi128_si256 (__m128i a) /// - public static Vector256 ZeroExtendToVector256(Vector128 value) where T : struct { throw new NotImplementedException(); } + public static Vector256 ZeroExtendToVector256(Vector128 value) where T : struct => ZeroExtendToVector256(value); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs new file mode 100644 index 000000000000..97e1074ef6f7 --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs @@ -0,0 +1,1362 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel AVX2 hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Avx2 + { + public static bool IsSupported { get { return false; } } + + /// + /// __m256i _mm256_abs_epi8 (__m256i a) + /// + public static Vector256 Abs(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_abs_epi16 (__m256i a) + /// + public static Vector256 Abs(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_abs_epi32 (__m256i a) + /// + public static Vector256 Abs(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) + /// + public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) + /// + public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) + /// + public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) + /// + public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) + /// + public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) + /// + public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) + /// + public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) + /// + public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_adds_epi8 (__m256i a, __m256i b) + /// + public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_adds_epu8 (__m256i a, __m256i b) + /// + public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_adds_epi16 (__m256i a, __m256i b) + /// + public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_adds_epu16 (__m256i a, __m256i b) + /// + public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// + public static Vector256 AlignRight(Vector256 left, Vector256 right, byte mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// + public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// + public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// + public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// + public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// + public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// + public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// + public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// + public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// + public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// + public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// + public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// + public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// + public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// + public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// + public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// + public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_avg_epu8 (__m256i a, __m256i b) + /// + public static Vector256 Average(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_avg_epu16 (__m256i a, __m256i b) + /// + public static Vector256 Average(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// + public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// + public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_broadcastb_epi8 (__m128i a) + /// __m128i _mm_broadcastw_epi16 (__m128i a) + /// __m128i _mm_broadcastd_epi32 (__m128i a) + /// __m128i _mm_broadcastq_epi64 (__m128i a) + /// __m128 _mm_broadcastss_ps (__m128 a) + /// __m128d _mm_broadcastsd_pd (__m128d a) + /// + public static Vector128 BroadcastElementToVector128(Vector128 value) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_broadcastb_epi8 (__m128i a) + /// __m256i _mm256_broadcastw_epi16 (__m128i a) + /// __m256i _mm256_broadcastd_epi32 (__m128i a) + /// __m256i _mm256_broadcastq_epi64 (__m128i a) + /// __m256 _mm256_broadcastss_ps (__m128 a) + /// __m256d _mm256_broadcastsd_pd (__m128d a) + /// + public static Vector256 BroadcastElementToVector256(Vector128 value) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// + public static unsafe Vector256 BroadcastVector128ToVector256(sbyte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// + public static unsafe Vector256 BroadcastVector128ToVector256(byte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// + public static unsafe Vector256 BroadcastVector128ToVector256(short* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// + public static unsafe Vector256 BroadcastVector128ToVector256(ushort* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// + public static unsafe Vector256 BroadcastVector128ToVector256(int* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// + public static unsafe Vector256 BroadcastVector128ToVector256(uint* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// + public static unsafe Vector256 BroadcastVector128ToVector256(long* address) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// + public static unsafe Vector256 BroadcastVector128ToVector256(ulong* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) + /// + public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) + /// + public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) + /// + public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) + /// + public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) + /// + public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) + /// + public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) + /// + public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) + /// + public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_cmpgt_epi8 (__m256i a, __m256i b) + /// + public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cmpgt_epi16 (__m256i a, __m256i b) + /// + public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cmpgt_epi32 (__m256i a, __m256i b) + /// + public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cmpgt_epi64 (__m256i a, __m256i b) + /// + public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_cvtepi8_epi16 (__m128i a) + /// + public static Vector256 ConvertToVector256Short(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepu8_epi16 (__m128i a) + /// + public static Vector256 ConvertToVector256UShort(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepi8_epi32 (__m128i a) + /// + public static Vector256 ConvertToVector256Int(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepi16_epi32 (__m128i a) + /// + public static Vector256 ConvertToVector256Int(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepu8_epi32 (__m128i a) + /// + public static Vector256 ConvertToVector256UInt(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepu16_epi32 (__m128i a) + /// + public static Vector256 ConvertToVector256UInt(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepi8_epi64 (__m128i a) + /// + public static Vector256 ConvertToVector256Long(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepi16_epi64 (__m128i a) + /// + public static Vector256 ConvertToVector256Long(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepi32_epi64 (__m128i a) + /// + public static Vector256 ConvertToVector256Long(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepu8_epi64 (__m128i a) + /// + public static Vector256 ConvertToVector256ULong(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepu16_epi64 (__m128i a) + /// + public static Vector256 ConvertToVector256ULong(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_cvtepu32_epi64 (__m128i a) + /// + public static Vector256 ConvertToVector256ULong(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + // + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(sbyte* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(byte* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(short* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(ushort* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(int* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(uint* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(long* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// + public static unsafe void ExtractVector128(ulong* address, Vector256 value, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(long* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm_i32gather_ps (float const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(float* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(double* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(long* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm_i64gather_ps (float const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(float* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_i64gather_pd (double const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(double* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// + public static unsafe Vector256 GatherVector256(int* baseAddress, Vector256 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// + public static unsafe Vector256 GatherVector256(uint* baseAddress, Vector256 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector256 GatherVector256(long* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_i32gather_ps (float const* base_addr, __m256i vindex, const int scale) + /// + public static unsafe Vector256 GatherVector256(float* baseAddress, Vector256 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) + /// + public static unsafe Vector256 GatherVector256(double* baseAddress, Vector128 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(int* baseAddress, Vector256 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector256 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) + /// + public static unsafe Vector256 GatherVector256(long* baseAddress, Vector256 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) + /// + public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector256 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm256_i64gather_ps (float const* base_addr, __m256i vindex, const int scale) + /// + public static unsafe Vector128 GatherVector128(float* baseAddress, Vector256 index, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_i64gather_pd (double const* base_addr, __m256i vindex, const int scale) + /// + public static unsafe Vector256 GatherVector256(double* baseAddress, Vector256 index, byte scale) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, long* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, ulong* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm_mask_i32gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_mask_i32gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, double* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, long* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, ulong* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm_mask_i64gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_mask_i64gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, double* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// + public static unsafe Vector256 GatherMaskVector256(Vector256 source, int* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// + public static unsafe Vector256 GatherMaskVector256(Vector256 source, uint* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) + /// + public static unsafe Vector256 GatherMaskVector256(Vector256 source, long* baseAddress, Vector128 index, Vector256 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) + /// + public static unsafe Vector256 GatherMaskVector256(Vector256 source, ulong* baseAddress, Vector128 index, Vector256 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_mask_i32gather_ps (__m256 src, float const* base_addr, __m256i vindex, __m256 mask, const int scale) + /// + public static unsafe Vector256 GatherMaskVector256(Vector256 source, float* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_mask_i32gather_pd (__m256d src, double const* base_addr, __m128i vindex, __m256d mask, const int scale) + /// + public static unsafe Vector256 GatherMaskVector256(Vector256 source, double* baseAddress, Vector128 index, Vector256 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector256 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector256 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// + public static unsafe Vector256 GatherMaskVector256(Vector256 source, long* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// + public static unsafe Vector256 GatherMaskVector256(Vector256 source, ulong* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm256_mask_i64gather_ps (__m128 src, float const* base_addr, __m256i vindex, __m128 mask, const int scale) + /// + public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector256 index, Vector128 mask, byte scale) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_mask_i64gather_pd (__m256d src, double const* base_addr, __m256i vindex, __m256d mask, const int scale) + /// + public static unsafe Vector256 GatherMaskVector256(Vector256 source, double* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_hadd_epi16 (__m256i a, __m256i b) + /// + public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_hadd_epi32 (__m256i a, __m256i b) + /// + public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_hadds_epi16 (__m256i a, __m256i b) + /// + public static Vector256 HorizontalAddSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_hsub_epi16 (__m256i a, __m256i b) + /// + public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_hsub_epi32 (__m256i a, __m256i b) + /// + public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_hsubs_epi16 (__m256i a, __m256i b) + /// + public static Vector256 HorizontalSubtractSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, sbyte* address, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, byte* address, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, short* address, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, ushort* address, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, int* address, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, uint* address, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, long* address, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// + public static unsafe Vector256 Insert(Vector256 value, ulong* address, byte index) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) + /// + public static unsafe Vector128 MaskLoad(int* address, Vector128 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) + /// + public static unsafe Vector128 MaskLoad(uint* address, Vector128 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) + /// + public static unsafe Vector128 MaskLoad(long* address, Vector128 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) + /// + public static unsafe Vector128 MaskLoad(ulong* address, Vector128 mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) + /// + public static unsafe Vector256 MaskLoad(int* address, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) + /// + public static unsafe Vector256 MaskLoad(uint* address, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) + /// + public static unsafe Vector256 MaskLoad(long* address, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) + /// + public static unsafe Vector256 MaskLoad(ulong* address, Vector256 mask) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) + /// + public static unsafe void MaskStore(int* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) + /// + public static unsafe void MaskStore(uint* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) + /// + public static unsafe void MaskStore(long* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) + /// + public static unsafe void MaskStore(ulong* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) + /// + public static unsafe void MaskStore(int* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) + /// + public static unsafe void MaskStore(uint* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) + /// + public static unsafe void MaskStore(long* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) + /// + public static unsafe void MaskStore(ulong* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_madd_epi16 (__m256i a, __m256i b) + /// + public static Vector256 MultiplyAddAdjacent(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_maddubs_epi16 (__m256i a, __m256i b) + /// + public static Vector256 MultiplyAddAdjacent(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_max_epi8 (__m256i a, __m256i b) + /// + public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_max_epu8 (__m256i a, __m256i b) + /// + public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_max_epi16 (__m256i a, __m256i b) + /// + public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_max_epu16 (__m256i a, __m256i b) + /// + public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_max_epi32 (__m256i a, __m256i b) + /// + public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_max_epu32 (__m256i a, __m256i b) + /// + public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_min_epi8 (__m256i a, __m256i b) + /// + public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_min_epu8 (__m256i a, __m256i b) + /// + public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_min_epi16 (__m256i a, __m256i b) + /// + public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_min_epu16 (__m256i a, __m256i b) + /// + public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_min_epi32 (__m256i a, __m256i b) + /// + public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_min_epu32 (__m256i a, __m256i b) + /// + public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm256_movemask_epi8 (__m256i a) + /// + public static int MoveMask(Vector256 value) { throw new PlatformNotSupportedException(); } + /// + /// int _mm256_movemask_epi8 (__m256i a) + /// + public static int MoveMask(Vector256 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 MultipleSumAbsoluteDifferences(Vector256 left, Vector256 right, byte mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_mul_epi32 (__m256i a, __m256i b) + /// + public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_mul_epu32 (__m256i a, __m256i b) + /// + public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_mulhi_epi16 (__m256i a, __m256i b) + /// + public static Vector256 MultiplyHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_mulhi_epu16 (__m256i a, __m256i b) + /// + public static Vector256 MultiplyHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_mulhrs_epi16 (__m256i a, __m256i b) + /// + public static Vector256 MultiplyHighRoundScale(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b) + /// + public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_mullo_epu16 (__m256i a, __m256i b) + /// + public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// + public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// + public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// + public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// + public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// + public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// + public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// + public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// + public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_packs_epi16 (__m256i a, __m256i b) + /// + public static Vector256 PackSignedSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_packs_epi32 (__m256i a, __m256i b) + /// + public static Vector256 PackSignedSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_packus_epi16 (__m256i a, __m256i b) + /// + public static Vector256 PackUnsignedSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_packus_epi32 (__m256i a, __m256i b) + /// + public static Vector256 PackUnsignedSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) + /// + public static Vector256 Permute4x64(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) + /// + public static Vector256 Permute4x64(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_permute4x64_pd (__m256d a, const int imm8) + /// + public static Vector256 Permute4x64(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) + /// + public static Vector256 PermuteVar8x32(Vector256 left, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) + /// + public static Vector256 PermuteVar8x32(Vector256 left, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx) + /// + public static Vector256 PermuteVar8x32(Vector256 left, Vector256 mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) + /// + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) + /// + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) + /// + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) + /// + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) + /// + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) + /// + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) + /// + public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) + /// + public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) + /// + public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) + /// + public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_srai_epi16 (__m256i a, int imm8) + /// + public static Vector256 ShiftRightArithmetic(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_srai_epi32 (__m256i a, int imm8) + /// + public static Vector256 ShiftRightArithmetic(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_srav_epi32 (__m256i a, __m256i count) + /// + public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) + /// + public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) + /// + public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) + /// + public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) + /// + public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) + /// + public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) + /// + public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) + /// + public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) + /// + public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) + /// + public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) + /// + public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) + /// + public static Vector256 Shuffle(Vector256 value, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) + /// + public static Vector256 Shuffle(Vector256 value, Vector256 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) + /// + public static Vector256 Shuffle(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) + /// + public static Vector256 Shuffle(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) + /// + public static Vector256 ShuffleHigh(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) + /// + public static Vector256 ShuffleHigh(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) + /// + public static Vector256 ShuffleLow(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) + /// + public static Vector256 ShuffleLow(Vector256 value, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_sign_epi8 (__m256i a, __m256i b) + /// + public static Vector256 Sign(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sign_epi16 (__m256i a, __m256i b) + /// + public static Vector256 Sign(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sign_epi32 (__m256i a, __m256i b) + /// + public static Vector256 Sign(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) + /// + public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) + /// + public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) + /// + public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) + /// + public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) + /// + public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) + /// + public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) + /// + public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) + /// + public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_subs_epi8 (__m256i a, __m256i b) + /// + public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_subs_epi16 (__m256i a, __m256i b) + /// + public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_subs_epu8 (__m256i a, __m256i b) + /// + public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_subs_epu16 (__m256i a, __m256i b) + /// + public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_sad_epu8 (__m256i a, __m256i b) + /// + public static Vector256 SumAbsoluteDifferences(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) + /// + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) + /// + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) + /// + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) + /// + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) + /// + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) + /// + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) + /// + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) + /// + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) + /// + public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) + /// + public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) + /// + public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) + /// + public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) + /// + public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) + /// + public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) + /// + public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) + /// + public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// + public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// + public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// + public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// + public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// + public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// + public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// + public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + /// + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// + public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.cs index cd652c26e2ac..f8ee1fdcb431 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.cs @@ -13,184 +13,184 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Avx2 { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// __m256i _mm256_abs_epi8 (__m256i a) /// - public static Vector256 Abs(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 Abs(Vector256 value) => Abs(value); /// /// __m256i _mm256_abs_epi16 (__m256i a) /// - public static Vector256 Abs(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 Abs(Vector256 value) => Abs(value); /// /// __m256i _mm256_abs_epi32 (__m256i a) /// - public static Vector256 Abs(Vector256 value) { throw new NotImplementedException(); } + public static Vector256 Abs(Vector256 value) => Abs(value); /// /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) /// - public static Vector256 Add(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) /// - public static Vector256 Add(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) /// - public static Vector256 Add(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) /// - public static Vector256 Add(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) /// - public static Vector256 Add(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) /// - public static Vector256 Add(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) /// - public static Vector256 Add(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) /// - public static Vector256 Add(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// /// __m256i _mm256_adds_epi8 (__m256i a, __m256i b) /// - public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AddSaturate(Vector256 left, Vector256 right) => AddSaturate(left, right); /// /// __m256i _mm256_adds_epu8 (__m256i a, __m256i b) /// - public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AddSaturate(Vector256 left, Vector256 right) => AddSaturate(left, right); /// /// __m256i _mm256_adds_epi16 (__m256i a, __m256i b) /// - public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AddSaturate(Vector256 left, Vector256 right) => AddSaturate(left, right); /// /// __m256i _mm256_adds_epu16 (__m256i a, __m256i b) /// - public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AddSaturate(Vector256 left, Vector256 right) => AddSaturate(left, right); /// /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) /// - public static Vector256 AlignRight(Vector256 left, Vector256 right, byte mask) { throw new NotImplementedException(); } + public static Vector256 AlignRight(Vector256 left, Vector256 right, byte mask) => AlignRight(left, right, mask); /// /// __m256i _mm256_and_si256 (__m256i a, __m256i b) /// - public static Vector256 And(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// /// __m256i _mm256_and_si256 (__m256i a, __m256i b) /// - public static Vector256 And(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// /// __m256i _mm256_and_si256 (__m256i a, __m256i b) /// - public static Vector256 And(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// /// __m256i _mm256_and_si256 (__m256i a, __m256i b) /// - public static Vector256 And(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// /// __m256i _mm256_and_si256 (__m256i a, __m256i b) /// - public static Vector256 And(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// /// __m256i _mm256_and_si256 (__m256i a, __m256i b) /// - public static Vector256 And(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// /// __m256i _mm256_and_si256 (__m256i a, __m256i b) /// - public static Vector256 And(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// /// __m256i _mm256_and_si256 (__m256i a, __m256i b) /// - public static Vector256 And(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) /// - public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) /// - public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) /// - public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) /// - public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) /// - public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) /// - public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) /// - public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) /// - public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// /// __m256i _mm256_avg_epu8 (__m256i a, __m256i b) /// - public static Vector256 Average(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Average(Vector256 left, Vector256 right) => Average(left, right); /// /// __m256i _mm256_avg_epu16 (__m256i a, __m256i b) /// - public static Vector256 Average(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Average(Vector256 left, Vector256 right) => Average(left, right); /// /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) /// - public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new NotImplementedException(); } + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) => Blend(left, right, control); /// /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) /// - public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new NotImplementedException(); } + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) => Blend(left, right, control); /// /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) => Blend(left, right, control); /// /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) => Blend(left, right, control); /// /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) => Blend(left, right, control); /// /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Blend(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Blend(Vector256 left, Vector256 right, byte control) => Blend(left, right, control); /// /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) /// - public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) /// - public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// /// __m128i _mm_broadcastb_epi8 (__m128i a) @@ -200,7 +200,7 @@ public static class Avx2 /// __m128 _mm_broadcastss_ps (__m128 a) /// __m128d _mm_broadcastsd_pd (__m128d a) /// - public static Vector128 BroadcastElementToVector128(Vector128 value) where T : struct { throw new NotImplementedException(); } + public static Vector128 BroadcastElementToVector128(Vector128 value) where T : struct => BroadcastElementToVector128(value); /// /// __m256i _mm256_broadcastb_epi8 (__m128i a) @@ -210,1153 +210,1153 @@ public static class Avx2 /// __m256 _mm256_broadcastss_ps (__m128 a) /// __m256d _mm256_broadcastsd_pd (__m128d a) /// - public static Vector256 BroadcastElementToVector256(Vector128 value) where T : struct { throw new NotImplementedException(); } + public static Vector256 BroadcastElementToVector256(Vector128 value) where T : struct => BroadcastElementToVector256(value); /// /// __m256i _mm256_broadcastsi128_si256 (__m128i a) /// - public static unsafe Vector256 BroadcastVector128ToVector256(sbyte* address) { throw new NotImplementedException(); } + public static unsafe Vector256 BroadcastVector128ToVector256(sbyte* address) => BroadcastVector128ToVector256(address); /// /// __m256i _mm256_broadcastsi128_si256 (__m128i a) /// - public static unsafe Vector256 BroadcastVector128ToVector256(byte* address) { throw new NotImplementedException(); } + public static unsafe Vector256 BroadcastVector128ToVector256(byte* address) => BroadcastVector128ToVector256(address); /// /// __m256i _mm256_broadcastsi128_si256 (__m128i a) /// - public static unsafe Vector256 BroadcastVector128ToVector256(short* address) { throw new NotImplementedException(); } + public static unsafe Vector256 BroadcastVector128ToVector256(short* address) => BroadcastVector128ToVector256(address); /// /// __m256i _mm256_broadcastsi128_si256 (__m128i a) /// - public static unsafe Vector256 BroadcastVector128ToVector256(ushort* address) { throw new NotImplementedException(); } + public static unsafe Vector256 BroadcastVector128ToVector256(ushort* address) => BroadcastVector128ToVector256(address); /// /// __m256i _mm256_broadcastsi128_si256 (__m128i a) /// - public static unsafe Vector256 BroadcastVector128ToVector256(int* address) { throw new NotImplementedException(); } + public static unsafe Vector256 BroadcastVector128ToVector256(int* address) => BroadcastVector128ToVector256(address); /// /// __m256i _mm256_broadcastsi128_si256 (__m128i a) /// - public static unsafe Vector256 BroadcastVector128ToVector256(uint* address) { throw new NotImplementedException(); } + public static unsafe Vector256 BroadcastVector128ToVector256(uint* address) => BroadcastVector128ToVector256(address); /// /// __m256i _mm256_broadcastsi128_si256 (__m128i a) /// - public static unsafe Vector256 BroadcastVector128ToVector256(long* address) { throw new NotImplementedException(); } + public static unsafe Vector256 BroadcastVector128ToVector256(long* address) => BroadcastVector128ToVector256(address); /// /// __m256i _mm256_broadcastsi128_si256 (__m128i a) /// - public static unsafe Vector256 BroadcastVector128ToVector256(ulong* address) { throw new NotImplementedException(); } + public static unsafe Vector256 BroadcastVector128ToVector256(ulong* address) => BroadcastVector128ToVector256(address); /// /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) /// - public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) /// - public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) /// - public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) /// - public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) /// - public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) /// - public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) /// - public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) /// - public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// /// __m256i _mm256_cmpgt_epi8 (__m256i a, __m256i b) /// - public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// /// __m256i _mm256_cmpgt_epi16 (__m256i a, __m256i b) /// - public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// /// __m256i _mm256_cmpgt_epi32 (__m256i a, __m256i b) /// - public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// /// __m256i _mm256_cmpgt_epi64 (__m256i a, __m256i b) /// - public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// /// __m256i _mm256_cvtepi8_epi16 (__m128i a) /// - public static Vector256 ConvertToVector256Short(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256Short(Vector128 value) => ConvertToVector256Short(value); /// /// __m256i _mm256_cvtepu8_epi16 (__m128i a) /// - public static Vector256 ConvertToVector256UShort(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256UShort(Vector128 value) => ConvertToVector256UShort(value); /// /// __m256i _mm256_cvtepi8_epi32 (__m128i a) /// - public static Vector256 ConvertToVector256Int(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256Int(Vector128 value) => ConvertToVector256Int(value); /// /// __m256i _mm256_cvtepi16_epi32 (__m128i a) /// - public static Vector256 ConvertToVector256Int(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256Int(Vector128 value) => ConvertToVector256Int(value); /// /// __m256i _mm256_cvtepu8_epi32 (__m128i a) /// - public static Vector256 ConvertToVector256UInt(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256UInt(Vector128 value) => ConvertToVector256UInt(value); /// /// __m256i _mm256_cvtepu16_epi32 (__m128i a) /// - public static Vector256 ConvertToVector256UInt(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256UInt(Vector128 value) => ConvertToVector256UInt(value); /// /// __m256i _mm256_cvtepi8_epi64 (__m128i a) /// - public static Vector256 ConvertToVector256Long(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256Long(Vector128 value) => ConvertToVector256Long(value); /// /// __m256i _mm256_cvtepi16_epi64 (__m128i a) /// - public static Vector256 ConvertToVector256Long(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256Long(Vector128 value) => ConvertToVector256Long(value); /// /// __m256i _mm256_cvtepi32_epi64 (__m128i a) /// - public static Vector256 ConvertToVector256Long(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256Long(Vector128 value) => ConvertToVector256Long(value); /// /// __m256i _mm256_cvtepu8_epi64 (__m128i a) /// - public static Vector256 ConvertToVector256ULong(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256ULong(Vector128 value) => ConvertToVector256ULong(value); /// /// __m256i _mm256_cvtepu16_epi64 (__m128i a) /// - public static Vector256 ConvertToVector256ULong(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256ULong(Vector128 value) => ConvertToVector256ULong(value); /// /// __m256i _mm256_cvtepu32_epi64 (__m128i a) /// - public static Vector256 ConvertToVector256ULong(Vector128 value) { throw new NotImplementedException(); } + public static Vector256 ConvertToVector256ULong(Vector128 value) => ConvertToVector256ULong(value); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new NotImplementedException(); } + public static Vector128 ExtractVector128(Vector256 value, byte index) => ExtractVector128(value, index); // /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(sbyte* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(sbyte* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new NotImplementedException(); } + public static Vector128 ExtractVector128(Vector256 value, byte index) => ExtractVector128(value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(byte* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(byte* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new NotImplementedException(); } + public static Vector128 ExtractVector128(Vector256 value, byte index) => ExtractVector128(value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(short* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(short* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new NotImplementedException(); } + public static Vector128 ExtractVector128(Vector256 value, byte index) => ExtractVector128(value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(ushort* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(ushort* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new NotImplementedException(); } + public static Vector128 ExtractVector128(Vector256 value, byte index) => ExtractVector128(value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(int* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(int* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new NotImplementedException(); } + public static Vector128 ExtractVector128(Vector256 value, byte index) => ExtractVector128(value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(uint* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(uint* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new NotImplementedException(); } + public static Vector128 ExtractVector128(Vector256 value, byte index) => ExtractVector128(value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(long* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(long* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static Vector128 ExtractVector128(Vector256 value, byte index) { throw new NotImplementedException(); } + public static Vector128 ExtractVector128(Vector256 value, byte index) => ExtractVector128(value, index); /// /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) /// - public static unsafe void ExtractVector128(ulong* address, Vector256 value, byte index) { throw new NotImplementedException(); } + public static unsafe void ExtractVector128(ulong* address, Vector256 value, byte index) => ExtractVector128(address, value, index); /// /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(long* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(long* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128 _mm_i32gather_ps (float const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(float* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(float* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128d _mm_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(double* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(double* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(long* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(long* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128 _mm_i64gather_ps (float const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(float* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(float* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128d _mm_i64gather_pd (double const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(double* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(double* baseAddress, Vector128 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) /// - public static unsafe Vector256 GatherVector256(int* baseAddress, Vector256 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherVector256(int* baseAddress, Vector256 index, byte scale) => GatherVector256(baseAddress, index, scale); /// /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) /// - public static unsafe Vector256 GatherVector256(uint* baseAddress, Vector256 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherVector256(uint* baseAddress, Vector256 index, byte scale) => GatherVector256(baseAddress, index, scale); /// /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector256 GatherVector256(long* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherVector256(long* baseAddress, Vector128 index, byte scale) => GatherVector256(baseAddress, index, scale); /// /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector128 index, byte scale) => GatherVector256(baseAddress, index, scale); /// /// __m256 _mm256_i32gather_ps (float const* base_addr, __m256i vindex, const int scale) /// - public static unsafe Vector256 GatherVector256(float* baseAddress, Vector256 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherVector256(float* baseAddress, Vector256 index, byte scale) => GatherVector256(baseAddress, index, scale); /// /// __m256d _mm256_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) /// - public static unsafe Vector256 GatherVector256(double* baseAddress, Vector128 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherVector256(double* baseAddress, Vector128 index, byte scale) => GatherVector256(baseAddress, index, scale); /// /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(int* baseAddress, Vector256 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(int* baseAddress, Vector256 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector256 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector256 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) /// - public static unsafe Vector256 GatherVector256(long* baseAddress, Vector256 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherVector256(long* baseAddress, Vector256 index, byte scale) => GatherVector256(baseAddress, index, scale); /// /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) /// - public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector256 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector256 index, byte scale) => GatherVector256(baseAddress, index, scale); /// /// __m128 _mm256_i64gather_ps (float const* base_addr, __m256i vindex, const int scale) /// - public static unsafe Vector128 GatherVector128(float* baseAddress, Vector256 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherVector128(float* baseAddress, Vector256 index, byte scale) => GatherVector128(baseAddress, index, scale); /// /// __m256d _mm256_i64gather_pd (double const* base_addr, __m256i vindex, const int scale) /// - public static unsafe Vector256 GatherVector256(double* baseAddress, Vector256 index, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherVector256(double* baseAddress, Vector256 index, byte scale) => GatherVector256(baseAddress, index, scale); /// /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, long* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, long* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, ulong* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, ulong* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128 _mm_mask_i32gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128d _mm_mask_i32gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, double* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, double* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, long* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, long* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, ulong* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, ulong* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128 _mm_mask_i64gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128d _mm_mask_i64gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, double* baseAddress, Vector128 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, double* baseAddress, Vector128 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) /// - public static unsafe Vector256 GatherMaskVector256(Vector256 source, int* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherMaskVector256(Vector256 source, int* baseAddress, Vector256 index, Vector256 mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale); /// /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) /// - public static unsafe Vector256 GatherMaskVector256(Vector256 source, uint* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherMaskVector256(Vector256 source, uint* baseAddress, Vector256 index, Vector256 mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale); /// /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) /// - public static unsafe Vector256 GatherMaskVector256(Vector256 source, long* baseAddress, Vector128 index, Vector256 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherMaskVector256(Vector256 source, long* baseAddress, Vector128 index, Vector256 mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale); /// /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) /// - public static unsafe Vector256 GatherMaskVector256(Vector256 source, ulong* baseAddress, Vector128 index, Vector256 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherMaskVector256(Vector256 source, ulong* baseAddress, Vector128 index, Vector256 mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale); /// /// __m256 _mm256_mask_i32gather_ps (__m256 src, float const* base_addr, __m256i vindex, __m256 mask, const int scale) /// - public static unsafe Vector256 GatherMaskVector256(Vector256 source, float* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherMaskVector256(Vector256 source, float* baseAddress, Vector256 index, Vector256 mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale); /// /// __m256d _mm256_mask_i32gather_pd (__m256d src, double const* base_addr, __m128i vindex, __m256d mask, const int scale) /// - public static unsafe Vector256 GatherMaskVector256(Vector256 source, double* baseAddress, Vector128 index, Vector256 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherMaskVector256(Vector256 source, double* baseAddress, Vector128 index, Vector256 mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale); /// /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector256 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector256 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector256 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector256 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) /// - public static unsafe Vector256 GatherMaskVector256(Vector256 source, long* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherMaskVector256(Vector256 source, long* baseAddress, Vector256 index, Vector256 mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale); /// /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) /// - public static unsafe Vector256 GatherMaskVector256(Vector256 source, ulong* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherMaskVector256(Vector256 source, ulong* baseAddress, Vector256 index, Vector256 mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale); /// /// __m128 _mm256_mask_i64gather_ps (__m128 src, float const* base_addr, __m256i vindex, __m128 mask, const int scale) /// - public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector256 index, Vector128 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector256 index, Vector128 mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale); /// /// __m256d _mm256_mask_i64gather_pd (__m256d src, double const* base_addr, __m256i vindex, __m256d mask, const int scale) /// - public static unsafe Vector256 GatherMaskVector256(Vector256 source, double* baseAddress, Vector256 index, Vector256 mask, byte scale) { throw new NotImplementedException(); } + public static unsafe Vector256 GatherMaskVector256(Vector256 source, double* baseAddress, Vector256 index, Vector256 mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale); /// /// __m256i _mm256_hadd_epi16 (__m256i a, __m256i b) /// - public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) => HorizontalAdd(left, right); /// /// __m256i _mm256_hadd_epi32 (__m256i a, __m256i b) /// - public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) => HorizontalAdd(left, right); /// /// __m256i _mm256_hadds_epi16 (__m256i a, __m256i b) /// - public static Vector256 HorizontalAddSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 HorizontalAddSaturate(Vector256 left, Vector256 right) => HorizontalAddSaturate(left, right); /// /// __m256i _mm256_hsub_epi16 (__m256i a, __m256i b) /// - public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) => HorizontalSubtract(left, right); /// /// __m256i _mm256_hsub_epi32 (__m256i a, __m256i b) /// - public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) => HorizontalSubtract(left, right); /// /// __m256i _mm256_hsubs_epi16 (__m256i a, __m256i b) /// - public static Vector256 HorizontalSubtractSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 HorizontalSubtractSaturate(Vector256 left, Vector256 right) => HorizontalSubtractSaturate(left, right); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new NotImplementedException(); } + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) => Insert(value, data, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, sbyte* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, sbyte* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new NotImplementedException(); } + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) => Insert(value, data, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, byte* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, byte* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new NotImplementedException(); } + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) => Insert(value, data, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, short* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, short* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new NotImplementedException(); } + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) => Insert(value, data, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, ushort* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, ushort* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new NotImplementedException(); } + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) => Insert(value, data, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, int* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, int* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new NotImplementedException(); } + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) => Insert(value, data, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, uint* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, uint* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new NotImplementedException(); } + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) => Insert(value, data, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, long* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, long* address, byte index) => Insert(value, address, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static Vector256 Insert(Vector256 value, Vector128 data, byte index) { throw new NotImplementedException(); } + public static Vector256 Insert(Vector256 value, Vector128 data, byte index) => Insert(value, data, index); /// /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) /// - public static unsafe Vector256 Insert(Vector256 value, ulong* address, byte index) { throw new NotImplementedException(); } + public static unsafe Vector256 Insert(Vector256 value, ulong* address, byte index) => Insert(value, address, index); /// /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) /// - public static unsafe Vector128 MaskLoad(int* address, Vector128 mask) { throw new NotImplementedException(); } + public static unsafe Vector128 MaskLoad(int* address, Vector128 mask) => MaskLoad(address, mask); /// /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) /// - public static unsafe Vector128 MaskLoad(uint* address, Vector128 mask) { throw new NotImplementedException(); } + public static unsafe Vector128 MaskLoad(uint* address, Vector128 mask) => MaskLoad(address, mask); /// /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) /// - public static unsafe Vector128 MaskLoad(long* address, Vector128 mask) { throw new NotImplementedException(); } + public static unsafe Vector128 MaskLoad(long* address, Vector128 mask) => MaskLoad(address, mask); /// /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) /// - public static unsafe Vector128 MaskLoad(ulong* address, Vector128 mask) { throw new NotImplementedException(); } + public static unsafe Vector128 MaskLoad(ulong* address, Vector128 mask) => MaskLoad(address, mask); /// /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) /// - public static unsafe Vector256 MaskLoad(int* address, Vector256 mask) { throw new NotImplementedException(); } + public static unsafe Vector256 MaskLoad(int* address, Vector256 mask) => MaskLoad(address, mask); /// /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) /// - public static unsafe Vector256 MaskLoad(uint* address, Vector256 mask) { throw new NotImplementedException(); } + public static unsafe Vector256 MaskLoad(uint* address, Vector256 mask) => MaskLoad(address, mask); /// /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) /// - public static unsafe Vector256 MaskLoad(long* address, Vector256 mask) { throw new NotImplementedException(); } + public static unsafe Vector256 MaskLoad(long* address, Vector256 mask) => MaskLoad(address, mask); /// /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) /// - public static unsafe Vector256 MaskLoad(ulong* address, Vector256 mask) { throw new NotImplementedException(); } + public static unsafe Vector256 MaskLoad(ulong* address, Vector256 mask) => MaskLoad(address, mask); /// /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) /// - public static unsafe void MaskStore(int* address, Vector128 mask, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(int* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) /// - public static unsafe void MaskStore(uint* address, Vector128 mask, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(uint* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) /// - public static unsafe void MaskStore(long* address, Vector128 mask, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(long* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) /// - public static unsafe void MaskStore(ulong* address, Vector128 mask, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(ulong* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) /// - public static unsafe void MaskStore(int* address, Vector256 mask, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(int* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) /// - public static unsafe void MaskStore(uint* address, Vector256 mask, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(uint* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) /// - public static unsafe void MaskStore(long* address, Vector256 mask, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(long* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) /// - public static unsafe void MaskStore(ulong* address, Vector256 mask, Vector256 source) { throw new NotImplementedException(); } + public static unsafe void MaskStore(ulong* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// /// __m256i _mm256_madd_epi16 (__m256i a, __m256i b) /// - public static Vector256 MultiplyAddAdjacent(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 MultiplyAddAdjacent(Vector256 left, Vector256 right) => MultiplyAddAdjacent(left, right); /// /// __m256i _mm256_maddubs_epi16 (__m256i a, __m256i b) /// - public static Vector256 MultiplyAddAdjacent(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 MultiplyAddAdjacent(Vector256 left, Vector256 right) => MultiplyAddAdjacent(left, right); /// /// __m256i _mm256_max_epi8 (__m256i a, __m256i b) /// - public static Vector256 Max(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// /// __m256i _mm256_max_epu8 (__m256i a, __m256i b) /// - public static Vector256 Max(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// /// __m256i _mm256_max_epi16 (__m256i a, __m256i b) /// - public static Vector256 Max(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// /// __m256i _mm256_max_epu16 (__m256i a, __m256i b) /// - public static Vector256 Max(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// /// __m256i _mm256_max_epi32 (__m256i a, __m256i b) /// - public static Vector256 Max(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// /// __m256i _mm256_max_epu32 (__m256i a, __m256i b) /// - public static Vector256 Max(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// /// __m256i _mm256_min_epi8 (__m256i a, __m256i b) /// - public static Vector256 Min(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// /// __m256i _mm256_min_epu8 (__m256i a, __m256i b) /// - public static Vector256 Min(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// /// __m256i _mm256_min_epi16 (__m256i a, __m256i b) /// - public static Vector256 Min(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// /// __m256i _mm256_min_epu16 (__m256i a, __m256i b) /// - public static Vector256 Min(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// /// __m256i _mm256_min_epi32 (__m256i a, __m256i b) /// - public static Vector256 Min(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// /// __m256i _mm256_min_epu32 (__m256i a, __m256i b) /// - public static Vector256 Min(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// /// int _mm256_movemask_epi8 (__m256i a) /// - public static int MoveMask(Vector256 value) { throw new NotImplementedException(); } + public static int MoveMask(Vector256 value) => MoveMask(value); /// /// int _mm256_movemask_epi8 (__m256i a) /// - public static int MoveMask(Vector256 value) { throw new NotImplementedException(); } + public static int MoveMask(Vector256 value) => MoveMask(value); /// /// __m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 MultipleSumAbsoluteDifferences(Vector256 left, Vector256 right, byte mask) { throw new NotImplementedException(); } + public static Vector256 MultipleSumAbsoluteDifferences(Vector256 left, Vector256 right, byte mask) => MultipleSumAbsoluteDifferences(left, right, mask); /// /// __m256i _mm256_mul_epi32 (__m256i a, __m256i b) /// - public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Multiply(Vector256 left, Vector256 right) => Multiply(left, right); /// /// __m256i _mm256_mul_epu32 (__m256i a, __m256i b) /// - public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Multiply(Vector256 left, Vector256 right) => Multiply(left, right); /// /// __m256i _mm256_mulhi_epi16 (__m256i a, __m256i b) /// - public static Vector256 MultiplyHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 MultiplyHigh(Vector256 left, Vector256 right) => MultiplyHigh(left, right); /// /// __m256i _mm256_mulhi_epu16 (__m256i a, __m256i b) /// - public static Vector256 MultiplyHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 MultiplyHigh(Vector256 left, Vector256 right) => MultiplyHigh(left, right); /// /// __m256i _mm256_mulhrs_epi16 (__m256i a, __m256i b) /// - public static Vector256 MultiplyHighRoundScale(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 MultiplyHighRoundScale(Vector256 left, Vector256 right) => MultiplyHighRoundScale(left, right); /// /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b) /// - public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 MultiplyLow(Vector256 left, Vector256 right) => MultiplyLow(left, right); /// /// __m256i _mm256_mullo_epu16 (__m256i a, __m256i b) /// - public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 MultiplyLow(Vector256 left, Vector256 right) => MultiplyLow(left, right); /// /// __m256i _mm256_or_si256 (__m256i a, __m256i b) /// - public static Vector256 Or(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// /// __m256i _mm256_or_si256 (__m256i a, __m256i b) /// - public static Vector256 Or(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// /// __m256i _mm256_or_si256 (__m256i a, __m256i b) /// - public static Vector256 Or(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// /// __m256i _mm256_or_si256 (__m256i a, __m256i b) /// - public static Vector256 Or(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// /// __m256i _mm256_or_si256 (__m256i a, __m256i b) /// - public static Vector256 Or(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// /// __m256i _mm256_or_si256 (__m256i a, __m256i b) /// - public static Vector256 Or(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// /// __m256i _mm256_or_si256 (__m256i a, __m256i b) /// - public static Vector256 Or(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// /// __m256i _mm256_or_si256 (__m256i a, __m256i b) /// - public static Vector256 Or(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// /// __m256i _mm256_packs_epi16 (__m256i a, __m256i b) /// - public static Vector256 PackSignedSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 PackSignedSaturate(Vector256 left, Vector256 right) => PackSignedSaturate(left, right); /// /// __m256i _mm256_packs_epi32 (__m256i a, __m256i b) /// - public static Vector256 PackSignedSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 PackSignedSaturate(Vector256 left, Vector256 right) => PackSignedSaturate(left, right); /// /// __m256i _mm256_packus_epi16 (__m256i a, __m256i b) /// - public static Vector256 PackUnsignedSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 PackUnsignedSaturate(Vector256 left, Vector256 right) => PackUnsignedSaturate(left, right); /// /// __m256i _mm256_packus_epi32 (__m256i a, __m256i b) /// - public static Vector256 PackUnsignedSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 PackUnsignedSaturate(Vector256 left, Vector256 right) => PackUnsignedSaturate(left, right); /// /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) => Permute2x128(left, right, control); /// /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) => Permute2x128(left, right, control); /// /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) => Permute2x128(left, right, control); /// /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) => Permute2x128(left, right, control); /// /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) => Permute2x128(left, right, control); /// /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) => Permute2x128(left, right, control); /// /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) => Permute2x128(left, right, control); /// /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) /// - public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute2x128(Vector256 left, Vector256 right, byte control) => Permute2x128(left, right, control); /// /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) /// - public static Vector256 Permute4x64(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute4x64(Vector256 value, byte control) => Permute4x64(value, control); /// /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) /// - public static Vector256 Permute4x64(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute4x64(Vector256 value, byte control) => Permute4x64(value, control); /// /// __m256d _mm256_permute4x64_pd (__m256d a, const int imm8) /// - public static Vector256 Permute4x64(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 Permute4x64(Vector256 value, byte control) => Permute4x64(value, control); /// /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) /// - public static Vector256 PermuteVar8x32(Vector256 left, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 PermuteVar8x32(Vector256 left, Vector256 mask) => PermuteVar8x32(left, mask); /// /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) /// - public static Vector256 PermuteVar8x32(Vector256 left, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 PermuteVar8x32(Vector256 left, Vector256 mask) => PermuteVar8x32(left, mask); /// /// __m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx) /// - public static Vector256 PermuteVar8x32(Vector256 left, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 PermuteVar8x32(Vector256 left, Vector256 mask) => PermuteVar8x32(left, mask); /// /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) /// - public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) => ShiftLeftLogical(value, count); /// /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) /// - public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) => ShiftLeftLogical(value, count); /// /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) /// - public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) => ShiftLeftLogical(value, count); /// /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) /// - public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) => ShiftLeftLogical(value, count); /// /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) /// - public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) => ShiftLeftLogical(value, count); /// /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) /// - public static Vector256 ShiftLeftLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical(Vector256 value, byte count) => ShiftLeftLogical(value, count); /// /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) /// - public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) /// - public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) /// - public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) /// - public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new NotImplementedException(); } + public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// /// __m256i _mm256_srai_epi16 (__m256i a, int imm8) /// - public static Vector256 ShiftRightArithmetic(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightArithmetic(Vector256 value, byte count) => ShiftRightArithmetic(value, count); /// /// __m256i _mm256_srai_epi32 (__m256i a, int imm8) /// - public static Vector256 ShiftRightArithmetic(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightArithmetic(Vector256 value, byte count) => ShiftRightArithmetic(value, count); /// /// __m256i _mm256_srav_epi32 (__m256i a, __m256i count) /// - public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) => ShiftRightArithmeticVariable(value, count); /// /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) /// - public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical(Vector256 value, byte count) => ShiftRightLogical(value, count); /// /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) /// - public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical(Vector256 value, byte count) => ShiftRightLogical(value, count); /// /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) /// - public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical(Vector256 value, byte count) => ShiftRightLogical(value, count); /// /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) /// - public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical(Vector256 value, byte count) => ShiftRightLogical(value, count); /// /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) /// - public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical(Vector256 value, byte count) => ShiftRightLogical(value, count); /// /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) /// - public static Vector256 ShiftRightLogical(Vector256 value, byte count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical(Vector256 value, byte count) => ShiftRightLogical(value, count); /// /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) /// - public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogical128BitLane(Vector256 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) /// - public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) /// - public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) /// - public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) /// - public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new NotImplementedException(); } + public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) /// - public static Vector256 Shuffle(Vector256 value, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 Shuffle(Vector256 value, Vector256 mask) => Shuffle(value, mask); /// /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) /// - public static Vector256 Shuffle(Vector256 value, Vector256 mask) { throw new NotImplementedException(); } + public static Vector256 Shuffle(Vector256 value, Vector256 mask) => Shuffle(value, mask); /// /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) /// - public static Vector256 Shuffle(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 Shuffle(Vector256 value, byte control) => Shuffle(value, control); /// /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) /// - public static Vector256 Shuffle(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 Shuffle(Vector256 value, byte control) => Shuffle(value, control); /// /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) /// - public static Vector256 ShuffleHigh(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 ShuffleHigh(Vector256 value, byte control) => ShuffleHigh(value, control); /// /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) /// - public static Vector256 ShuffleHigh(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 ShuffleHigh(Vector256 value, byte control) => ShuffleHigh(value, control); /// /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) /// - public static Vector256 ShuffleLow(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 ShuffleLow(Vector256 value, byte control) => ShuffleLow(value, control); /// /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) /// - public static Vector256 ShuffleLow(Vector256 value, byte control) { throw new NotImplementedException(); } + public static Vector256 ShuffleLow(Vector256 value, byte control) => ShuffleLow(value, control); /// /// __m256i _mm256_sign_epi8 (__m256i a, __m256i b) /// - public static Vector256 Sign(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Sign(Vector256 left, Vector256 right) => Sign(left, right); /// /// __m256i _mm256_sign_epi16 (__m256i a, __m256i b) /// - public static Vector256 Sign(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Sign(Vector256 left, Vector256 right) => Sign(left, right); /// /// __m256i _mm256_sign_epi32 (__m256i a, __m256i b) /// - public static Vector256 Sign(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Sign(Vector256 left, Vector256 right) => Sign(left, right); /// /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) /// - public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) /// - public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) /// - public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) /// - public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) /// - public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) /// - public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) /// - public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) /// - public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// /// __m256i _mm256_subs_epi8 (__m256i a, __m256i b) /// - public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) => SubtractSaturate(left, right); /// /// __m256i _mm256_subs_epi16 (__m256i a, __m256i b) /// - public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) => SubtractSaturate(left, right); /// /// __m256i _mm256_subs_epu8 (__m256i a, __m256i b) /// - public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) => SubtractSaturate(left, right); /// /// __m256i _mm256_subs_epu16 (__m256i a, __m256i b) /// - public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) => SubtractSaturate(left, right); /// /// __m256i _mm256_sad_epu8 (__m256i a, __m256i b) /// - public static Vector256 SumAbsoluteDifferences(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 SumAbsoluteDifferences(Vector256 left, Vector256 right) => SumAbsoluteDifferences(left, right); /// /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) /// - public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) /// - public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) /// - public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) /// - public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) /// - public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) /// - public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) /// - public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) /// - public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) /// - public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) /// - public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) /// - public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) /// - public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) /// - public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) /// - public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) /// - public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) /// - public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) /// - public static Vector256 Xor(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) /// - public static Vector256 Xor(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) /// - public static Vector256 Xor(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) /// - public static Vector256 Xor(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) /// - public static Vector256 Xor(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) /// - public static Vector256 Xor(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) /// - public static Vector256 Xor(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) /// - public static Vector256 Xor(Vector256 left, Vector256 right) { throw new NotImplementedException(); } + public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs new file mode 100644 index 000000000000..eb2e30a2c143 --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs @@ -0,0 +1,80 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel BMI1 hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Bmi1 + { + public static bool IsSupported { get { return false; } } + + /// + /// unsigned int _andn_u32 (unsigned int a, unsigned int b) + /// + public static uint AndNot(uint left, uint right) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _andn_u64 (unsigned __int64 a, unsigned __int64 b) + /// + public static ulong AndNot(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + /// + /// unsigned int _bextr_u32 (unsigned int a, unsigned int start, unsigned int len) + /// + public static uint BitFieldExtract(uint value, uint start, uint length) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _bextr_u64 (unsigned __int64 a, unsigned int start, unsigned int len) + /// + public static ulong BitFieldExtract(ulong value, ulong start, ulong length) { throw new PlatformNotSupportedException(); } + /// + /// unsigned int _bextr2_u32 (unsigned int a, unsigned int control) + /// + public static uint BitFieldExtract(uint value, uint control) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _bextr2_u64 (unsigned __int64 a, unsigned __int64 control) + /// + public static ulong BitFieldExtract(ulong value, ulong control) { throw new PlatformNotSupportedException(); } + + /// + /// unsigned int _blsi_u32 (unsigned int a) + /// + public static uint ExtractLowestSetBit(uint value) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _blsi_u64 (unsigned __int64 a) + /// + public static ulong ExtractLowestSetBit(ulong value) { throw new PlatformNotSupportedException(); } + + /// + /// unsigned int _blsmsk_u32 (unsigned int a) + /// + public static uint GetMaskUptoLowestSetBit(uint value) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _blsmsk_u64 (unsigned __int64 a) + /// + public static ulong GetMaskUptoLowestSetBit(ulong value) { throw new PlatformNotSupportedException(); } + + /// + /// unsigned int _blsr_u32 (unsigned int a) + /// + public static uint ResetLowestSetBit(uint value) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _blsr_u64 (unsigned __int64 a) + /// + public static ulong ResetLowestSetBit(ulong value) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_tzcnt_32 (unsigned int a) + /// + public static uint TrailingZeroCount(uint value) { throw new PlatformNotSupportedException(); } + /// + /// __int64 _mm_tzcnt_64 (unsigned __int64 a) + /// + public static ulong TrailingZeroCount(ulong value) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi1.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi1.cs index a2bfcffedc35..628c83b6cd8c 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi1.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi1.cs @@ -13,68 +13,68 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Bmi1 { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// unsigned int _andn_u32 (unsigned int a, unsigned int b) /// - public static uint AndNot(uint left, uint right) { throw new NotImplementedException(); } + public static uint AndNot(uint left, uint right) => AndNot(left, right); /// /// unsigned __int64 _andn_u64 (unsigned __int64 a, unsigned __int64 b) /// - public static ulong AndNot(ulong left, ulong right) { throw new NotImplementedException(); } + public static ulong AndNot(ulong left, ulong right) => AndNot(left, right); /// /// unsigned int _bextr_u32 (unsigned int a, unsigned int start, unsigned int len) /// - public static uint BitFieldExtract(uint value, uint start, uint length) { throw new NotImplementedException(); } + public static uint BitFieldExtract(uint value, uint start, uint length) => BitFieldExtract(value, start, length); /// /// unsigned __int64 _bextr_u64 (unsigned __int64 a, unsigned int start, unsigned int len) /// - public static ulong BitFieldExtract(ulong value, ulong start, ulong length) { throw new NotImplementedException(); } + public static ulong BitFieldExtract(ulong value, ulong start, ulong length) => BitFieldExtract(value, start, length); /// /// unsigned int _bextr2_u32 (unsigned int a, unsigned int control) /// - public static uint BitFieldExtract(uint value, uint control) { throw new NotImplementedException(); } + public static uint BitFieldExtract(uint value, uint control) => BitFieldExtract(value, control); /// /// unsigned __int64 _bextr2_u64 (unsigned __int64 a, unsigned __int64 control) /// - public static ulong BitFieldExtract(ulong value, ulong control) { throw new NotImplementedException(); } + public static ulong BitFieldExtract(ulong value, ulong control) => BitFieldExtract(value, control); /// /// unsigned int _blsi_u32 (unsigned int a) /// - public static uint ExtractLowestSetBit(uint value) { throw new NotImplementedException(); } + public static uint ExtractLowestSetBit(uint value) => ExtractLowestSetBit(value); /// /// unsigned __int64 _blsi_u64 (unsigned __int64 a) /// - public static ulong ExtractLowestSetBit(ulong value) { throw new NotImplementedException(); } + public static ulong ExtractLowestSetBit(ulong value) => ExtractLowestSetBit(value); /// /// unsigned int _blsmsk_u32 (unsigned int a) /// - public static uint GetMaskUptoLowestSetBit(uint value) { throw new NotImplementedException(); } + public static uint GetMaskUptoLowestSetBit(uint value) => GetMaskUptoLowestSetBit(value); /// /// unsigned __int64 _blsmsk_u64 (unsigned __int64 a) /// - public static ulong GetMaskUptoLowestSetBit(ulong value) { throw new NotImplementedException(); } + public static ulong GetMaskUptoLowestSetBit(ulong value) => GetMaskUptoLowestSetBit(value); /// /// unsigned int _blsr_u32 (unsigned int a) /// - public static uint ResetLowestSetBit(uint value) { throw new NotImplementedException(); } + public static uint ResetLowestSetBit(uint value) => ResetLowestSetBit(value); /// /// unsigned __int64 _blsr_u64 (unsigned __int64 a) /// - public static ulong ResetLowestSetBit(ulong value) { throw new NotImplementedException(); } + public static ulong ResetLowestSetBit(ulong value) => ResetLowestSetBit(value); /// /// int _mm_tzcnt_32 (unsigned int a) /// - public static uint TrailingZeroCount(uint value) { throw new NotImplementedException(); } + public static uint TrailingZeroCount(uint value) => TrailingZeroCount(value); /// /// __int64 _mm_tzcnt_64 (unsigned __int64 a) /// - public static ulong TrailingZeroCount(ulong value) { throw new NotImplementedException(); } + public static ulong TrailingZeroCount(ulong value) => TrailingZeroCount(value); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs new file mode 100644 index 000000000000..510186a2d1db --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs @@ -0,0 +1,54 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel BMI2 hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Bmi2 + { + public static bool IsSupported { get { return false; } } + + /// + /// unsigned int _bzhi_u32 (unsigned int a, unsigned int index) + /// + public static uint ZeroHighBits(uint value, uint index) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _bzhi_u64 (unsigned __int64 a, unsigned int index) + /// + public static ulong ZeroHighBits(ulong value, ulong index) { throw new PlatformNotSupportedException(); } + + /// + /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi) + /// + public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* high) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi) + /// + public static unsafe ulong MultiplyNoFlags(ulong left, ulong right, ulong* high) { throw new PlatformNotSupportedException(); } + + /// + /// unsigned int _pdep_u32 (unsigned int a, unsigned int mask) + /// + public static uint ParallelBitDeposit(uint value, uint mask) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _pdep_u64 (unsigned __int64 a, unsigned __int64 mask) + /// + public static ulong ParallelBitDeposit(ulong value, ulong mask) { throw new PlatformNotSupportedException(); } + + /// + /// unsigned int _pext_u32 (unsigned int a, unsigned int mask) + /// + public static uint ParallelBitExtract(uint value, uint mask) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _pext_u64 (unsigned __int64 a, unsigned __int64 mask) + /// + public static ulong ParallelBitExtract(ulong value, ulong mask) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi2.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi2.cs index a9a73de9263e..c6dfa72f4488 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi2.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Bmi2.cs @@ -13,42 +13,42 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Bmi2 { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// unsigned int _bzhi_u32 (unsigned int a, unsigned int index) /// - public static uint ZeroHighBits(uint value, uint index) { throw new NotImplementedException(); } + public static uint ZeroHighBits(uint value, uint index) => ZeroHighBits(value, index); /// /// unsigned __int64 _bzhi_u64 (unsigned __int64 a, unsigned int index) /// - public static ulong ZeroHighBits(ulong value, ulong index) { throw new NotImplementedException(); } + public static ulong ZeroHighBits(ulong value, ulong index) => ZeroHighBits(value, index); /// /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi) /// - public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* high) { throw new NotImplementedException(); } + public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* high) => MultiplyNoFlags(left, right, high); /// /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi) /// - public static unsafe ulong MultiplyNoFlags(ulong left, ulong right, ulong* high) { throw new NotImplementedException(); } + public static unsafe ulong MultiplyNoFlags(ulong left, ulong right, ulong* high) => MultiplyNoFlags(left, right, high); /// /// unsigned int _pdep_u32 (unsigned int a, unsigned int mask) /// - public static uint ParallelBitDeposit(uint value, uint mask) { throw new NotImplementedException(); } + public static uint ParallelBitDeposit(uint value, uint mask) => ParallelBitDeposit(value, mask); /// /// unsigned __int64 _pdep_u64 (unsigned __int64 a, unsigned __int64 mask) /// - public static ulong ParallelBitDeposit(ulong value, ulong mask) { throw new NotImplementedException(); } + public static ulong ParallelBitDeposit(ulong value, ulong mask) => ParallelBitDeposit(value, mask); /// /// unsigned int _pext_u32 (unsigned int a, unsigned int mask) /// - public static uint ParallelBitExtract(uint value, uint mask) { throw new NotImplementedException(); } + public static uint ParallelBitExtract(uint value, uint mask) => ParallelBitExtract(value, mask); /// /// unsigned __int64 _pext_u64 (unsigned __int64 a, unsigned __int64 mask) /// - public static ulong ParallelBitExtract(ulong value, ulong mask) { throw new NotImplementedException(); } + public static ulong ParallelBitExtract(ulong value, ulong mask) => ParallelBitExtract(value, mask); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs new file mode 100644 index 000000000000..c3adf712f8e9 --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs @@ -0,0 +1,119 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel FMA hardware instructions via intrinsics + /// + public static class Fma + { + public static bool IsSupported { get { return false; } } + + /// + /// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c) + /// + public static Vector128 MultiplyAdd(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_fmadd_pd (__m128d a, __m128d b, __m128d c) + /// + public static Vector128 MultiplyAdd(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_fmadd_ps (__m256 a, __m256 b, __m256 c) + /// + public static Vector256 MultiplyAdd(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_fmadd_pd (__m256d a, __m256d b, __m256d c) + /// + public static Vector256 MultiplyAdd(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_fmaddsub_ps (__m128 a, __m128 b, __m128 c) + /// + public static Vector128 MultiplyAddSubtract(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_fmaddsub_pd (__m128d a, __m128d b, __m128d c) + /// + public static Vector128 MultiplyAddSubtract(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_fmaddsub_ps (__m256 a, __m256 b, __m256 c) + /// + public static Vector256 MultiplyAddSubtract(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_fmaddsub_pd (__m256d a, __m256d b, __m256d c) + /// + public static Vector256 MultiplyAddSubtract(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_fmsub_ps (__m128 a, __m128 b, __m128 c) + /// + public static Vector128 MultiplySubtract(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_fmsub_pd (__m128d a, __m128d b, __m128d c) + /// + public static Vector128 MultiplySubtract(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_fmsub_ps (__m256 a, __m256 b, __m256 c) + /// + public static Vector256 MultiplySubtract(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_fmsub_pd (__m256d a, __m256d b, __m256d c) + /// + public static Vector256 MultiplySubtract(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_fmsubadd_ps (__m128 a, __m128 b, __m128 c) + /// + public static Vector128 MultiplySubtractAdd(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_fmsubadd_pd (__m128d a, __m128d b, __m128d c) + /// + public static Vector128 MultiplySubtractAdd(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_fmsubadd_ps (__m256 a, __m256 b, __m256 c) + /// + public static Vector256 MultiplySubtractAdd(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_fmsubadd_pd (__m256d a, __m256d b, __m256d c) + /// + public static Vector256 MultiplySubtractAdd(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_fnmadd_ps (__m128 a, __m128 b, __m128 c) + /// + public static Vector128 MultiplyAddNegated(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_fnmadd_pd (__m128d a, __m128d b, __m128d c) + /// + public static Vector128 MultiplyAddNegated(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_fnmadd_ps (__m256 a, __m256 b, __m256 c) + /// + public static Vector256 MultiplyAddNegated(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_fnmadd_pd (__m256d a, __m256d b, __m256d c) + /// + public static Vector256 MultiplyAddNegated(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c) + /// + public static Vector128 MultiplySubtractNegated(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_fnmsub_pd (__m128d a, __m128d b, __m128d c) + /// + public static Vector128 MultiplySubtractNegated(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256 _mm256_fnmsub_ps (__m256 a, __m256 b, __m256 c) + /// + public static Vector256 MultiplySubtractNegated(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + /// + /// __m256d _mm256_fnmsub_pd (__m256d a, __m256d b, __m256d c) + /// + public static Vector256 MultiplySubtractNegated(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.cs index 84160f293fbd..f4d053a07882 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.cs @@ -12,108 +12,108 @@ namespace System.Runtime.Intrinsics.X86 /// public static class Fma { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c) /// - public static Vector128 MultiplyAdd(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplyAdd(Vector128 a, Vector128 b, Vector128 c) => MultiplyAdd(a, b, c); /// /// __m128d _mm_fmadd_pd (__m128d a, __m128d b, __m128d c) /// - public static Vector128 MultiplyAdd(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplyAdd(Vector128 a, Vector128 b, Vector128 c) => MultiplyAdd(a, b, c); /// /// __m256 _mm256_fmadd_ps (__m256 a, __m256 b, __m256 c) /// - public static Vector256 MultiplyAdd(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplyAdd(Vector256 a, Vector256 b, Vector256 c) => MultiplyAdd(a, b, c); /// /// __m256d _mm256_fmadd_pd (__m256d a, __m256d b, __m256d c) /// - public static Vector256 MultiplyAdd(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplyAdd(Vector256 a, Vector256 b, Vector256 c) => MultiplyAdd(a, b, c); /// /// __m128 _mm_fmaddsub_ps (__m128 a, __m128 b, __m128 c) /// - public static Vector128 MultiplyAddSubtract(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplyAddSubtract(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddSubtract(a, b, c); /// /// __m128d _mm_fmaddsub_pd (__m128d a, __m128d b, __m128d c) /// - public static Vector128 MultiplyAddSubtract(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplyAddSubtract(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddSubtract(a, b, c); /// /// __m256 _mm256_fmaddsub_ps (__m256 a, __m256 b, __m256 c) /// - public static Vector256 MultiplyAddSubtract(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplyAddSubtract(Vector256 a, Vector256 b, Vector256 c) => MultiplyAddSubtract(a, b, c); /// /// __m256d _mm256_fmaddsub_pd (__m256d a, __m256d b, __m256d c) /// - public static Vector256 MultiplyAddSubtract(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplyAddSubtract(Vector256 a, Vector256 b, Vector256 c) => MultiplyAddSubtract(a, b, c); /// /// __m128 _mm_fmsub_ps (__m128 a, __m128 b, __m128 c) /// - public static Vector128 MultiplySubtract(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplySubtract(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtract(a, b, c); /// /// __m128d _mm_fmsub_pd (__m128d a, __m128d b, __m128d c) /// - public static Vector128 MultiplySubtract(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplySubtract(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtract(a, b, c); /// /// __m256 _mm256_fmsub_ps (__m256 a, __m256 b, __m256 c) /// - public static Vector256 MultiplySubtract(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplySubtract(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtract(a, b, c); /// /// __m256d _mm256_fmsub_pd (__m256d a, __m256d b, __m256d c) /// - public static Vector256 MultiplySubtract(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplySubtract(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtract(a, b, c); /// /// __m128 _mm_fmsubadd_ps (__m128 a, __m128 b, __m128 c) /// - public static Vector128 MultiplySubtractAdd(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplySubtractAdd(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractAdd(a, b, c); /// /// __m128d _mm_fmsubadd_pd (__m128d a, __m128d b, __m128d c) /// - public static Vector128 MultiplySubtractAdd(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplySubtractAdd(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractAdd(a, b, c); /// /// __m256 _mm256_fmsubadd_ps (__m256 a, __m256 b, __m256 c) /// - public static Vector256 MultiplySubtractAdd(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplySubtractAdd(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtractAdd(a, b, c); /// /// __m256d _mm256_fmsubadd_pd (__m256d a, __m256d b, __m256d c) /// - public static Vector256 MultiplySubtractAdd(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplySubtractAdd(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtractAdd(a, b, c); /// /// __m128 _mm_fnmadd_ps (__m128 a, __m128 b, __m128 c) /// - public static Vector128 MultiplyAddNegated(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplyAddNegated(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddNegated(a, b, c); /// /// __m128d _mm_fnmadd_pd (__m128d a, __m128d b, __m128d c) /// - public static Vector128 MultiplyAddNegated(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplyAddNegated(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddNegated(a, b, c); /// /// __m256 _mm256_fnmadd_ps (__m256 a, __m256 b, __m256 c) /// - public static Vector256 MultiplyAddNegated(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplyAddNegated(Vector256 a, Vector256 b, Vector256 c) => MultiplyAddNegated(a, b, c); /// /// __m256d _mm256_fnmadd_pd (__m256d a, __m256d b, __m256d c) /// - public static Vector256 MultiplyAddNegated(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplyAddNegated(Vector256 a, Vector256 b, Vector256 c) => MultiplyAddNegated(a, b, c); /// /// __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c) /// - public static Vector128 MultiplySubtractNegated(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplySubtractNegated(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractNegated(a, b, c); /// /// __m128d _mm_fnmsub_pd (__m128d a, __m128d b, __m128d c) /// - public static Vector128 MultiplySubtractNegated(Vector128 a, Vector128 b, Vector128 c) { throw new NotImplementedException(); } + public static Vector128 MultiplySubtractNegated(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractNegated(a, b, c); /// /// __m256 _mm256_fnmsub_ps (__m256 a, __m256 b, __m256 c) /// - public static Vector256 MultiplySubtractNegated(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplySubtractNegated(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtractNegated(a, b, c); /// /// __m256d _mm256_fnmsub_pd (__m256d a, __m256d b, __m256d c) /// - public static Vector256 MultiplySubtractNegated(Vector256 a, Vector256 b, Vector256 c) { throw new NotImplementedException(); } + public static Vector256 MultiplySubtractNegated(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtractNegated(a, b, c); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs new file mode 100644 index 000000000000..a305c806491e --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs @@ -0,0 +1,26 @@ +// 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; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel LZCNT hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Lzcnt + { + public static bool IsSupported { get { return false; } } + + /// + /// unsigned int _lzcnt_u32 (unsigned int a) + /// + public static uint LeadingZeroCount(uint value) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _lzcnt_u64 (unsigned __int64 a) + /// + public static ulong LeadingZeroCount(ulong value) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs index ffc656e43b11..17d7716fc018 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs @@ -3,7 +3,6 @@ // See the LICENSE file in the project root for more information. using System; -using System.Runtime.Intrinsics; namespace System.Runtime.Intrinsics.X86 { @@ -13,15 +12,15 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Lzcnt { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// unsigned int _lzcnt_u32 (unsigned int a) /// - public static uint LeadingZeroCount(uint value) { throw new NotImplementedException(); } + public static uint LeadingZeroCount(uint value) => LeadingZeroCount(value); /// /// unsigned __int64 _lzcnt_u64 (unsigned __int64 a) /// - public static ulong LeadingZeroCount(ulong value) { throw new NotImplementedException(); } + public static ulong LeadingZeroCount(ulong value) => LeadingZeroCount(value); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs new file mode 100644 index 000000000000..d2ee7f0bc63b --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs @@ -0,0 +1,27 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel PCLMULQDQ hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Pclmulqdq + { + public static bool IsSupported { get { return false; } } + + /// + /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 CarryLessMultiply(Vector128 left, Vector128 right, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 CarryLessMultiply(Vector128 left, Vector128 right, byte control) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs index f8576f89fe08..03cb3786539d 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs @@ -13,15 +13,15 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Pclmulqdq { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) /// - public static Vector128 CarryLessMultiply(Vector128 left, Vector128 right, byte control) { throw new NotImplementedException(); } + public static Vector128 CarryLessMultiply(Vector128 left, Vector128 right, byte control) => CarryLessMultiply(left, right, control); /// /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) /// - public static Vector128 CarryLessMultiply(Vector128 left, Vector128 right, byte control) { throw new NotImplementedException(); } + public static Vector128 CarryLessMultiply(Vector128 left, Vector128 right, byte control) => CarryLessMultiply(left, right, control); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs new file mode 100644 index 000000000000..f02db7a279ca --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs @@ -0,0 +1,26 @@ +// 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; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel POPCNT hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Popcnt + { + public static bool IsSupported { get { return false; } } + + /// + /// int _mm_popcnt_u32 (unsigned int a) + /// + public static int PopCount(uint value) { throw new PlatformNotSupportedException(); } + /// + /// __int64 _mm_popcnt_u64 (unsigned __int64 a) + /// + public static long PopCount(ulong value) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Popcnt.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Popcnt.cs index 66f2ab127dd8..c9e71b3a4752 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Popcnt.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Popcnt.cs @@ -3,7 +3,6 @@ // See the LICENSE file in the project root for more information. using System; -using System.Runtime.Intrinsics; namespace System.Runtime.Intrinsics.X86 { @@ -13,15 +12,15 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Popcnt { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// int _mm_popcnt_u32 (unsigned int a) /// - public static int PopCount(uint value) { throw new NotImplementedException(); } + public static int PopCount(uint value) => PopCount(value); /// /// __int64 _mm_popcnt_u64 (unsigned __int64 a) /// - public static long PopCount(ulong value) { throw new NotImplementedException(); } + public static long PopCount(ulong value) => PopCount(value); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs new file mode 100644 index 000000000000..fa91c5055e90 --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs @@ -0,0 +1,218 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel SSE hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Sse + { + public static bool IsSupported { get { return false; } } + + /// + /// __m128 _mm_add_ps (__m128 a, __m128 b) + /// + public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_and_ps (__m128 a, __m128 b) + /// + public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_andnot_ps (__m128 a, __m128 b) + /// + public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmpeq_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmpgt_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmpge_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmplt_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmple_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmpneq_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmpngt_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareNotGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmpnge_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareNotGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmpnlt_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareNotLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmpnle_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareNotLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmpord_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareOrdered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_cmpunord_ps (__m128 a, __m128 b) + /// + public static Vector128 CompareUnordered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_div_ps (__m128 a, __m128 b) + /// + public static Vector128 Divide(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_loadu_ps (float const* mem_address) + /// + public static unsafe Vector128 Load(float* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_load_ps (float const* mem_address) + /// + public static unsafe Vector128 LoadAligned(float* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_max_ps (__m128 a, __m128 b) + /// + public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_min_ps (__m128 a, __m128 b) + /// + public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_movehl_ps (__m128 a, __m128 b) + /// + public static Vector128 MoveHighToLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_movelh_ps (__m128 a, __m128 b) + /// + public static Vector128 MoveLowToHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_mul_ps (__m128 a, __m128 b) + /// + public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_or_ps (__m128 a, __m128 b) + /// + public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_rcp_ps (__m128 a) + /// + public static Vector128 Reciprocal(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_rsqrt_ps (__m128 a) + /// + public static Vector128 ReciprocalSquareRoot(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_set_ps (float e3, float e2, float e1, float e0) + /// + public static Vector128 Set(float e3, float e2, float e1, float e0) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_set1_ps (float a) + /// + public static Vector128 Set1(float value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_setzero_ps (void) + /// + public static Vector128 SetZero() { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_castpd_ps (__m128d a) + /// __m128i _mm_castpd_si128 (__m128d a) + /// __m128d _mm_castps_pd (__m128 a) + /// __m128i _mm_castps_si128 (__m128 a) + /// __m128d _mm_castsi128_pd (__m128i a) + /// __m128 _mm_castsi128_ps (__m128i a) + /// + public static Vector128 StaticCast(Vector128 value) where T : struct where U : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_shuffle_ps (__m128 a, __m128 b, unsigned int control) + /// + public static Vector128 Shuffle(Vector128 left, Vector128 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_sqrt_ps (__m128 a) + /// + public static Vector128 Sqrt(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_store_ps (float* mem_addr, __m128 a) + /// + public static unsafe void StoreAligned(float* address, Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_stream_ps (float* mem_addr, __m128 a) + /// + public static unsafe void StoreAlignedNonTemporal(float* address, Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_storeu_ps (float* mem_addr, __m128 a) + /// + public static unsafe void Store(float* address, Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_sub_ps (__m128d a, __m128d b) + /// + public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_unpackhi_ps (__m128 a, __m128 b) + /// + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_unpacklo_ps (__m128 a, __m128 b) + /// + public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_xor_ps (__m128 a, __m128 b) + /// + public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.cs index c85aee30155a..bd48cd8e4d4f 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.cs @@ -13,152 +13,152 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Sse { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// __m128 _mm_add_ps (__m128 a, __m128 b) /// - public static Vector128 Add(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// /// __m128 _mm_and_ps (__m128 a, __m128 b) /// - public static Vector128 And(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// /// __m128 _mm_andnot_ps (__m128 a, __m128 b) /// - public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// /// __m128 _mm_cmpeq_ps (__m128 a, __m128 b) /// - public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// /// __m128 _mm_cmpgt_ps (__m128 a, __m128 b) /// - public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// /// __m128 _mm_cmpge_ps (__m128 a, __m128 b) /// - public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// /// __m128 _mm_cmplt_ps (__m128 a, __m128 b) /// - public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// /// __m128 _mm_cmple_ps (__m128 a, __m128 b) /// - public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// /// __m128 _mm_cmpneq_ps (__m128 a, __m128 b) /// - public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// /// __m128 _mm_cmpngt_ps (__m128 a, __m128 b) /// - public static Vector128 CompareNotGreaterThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareNotGreaterThan(Vector128 left, Vector128 right) => CompareNotGreaterThan(left, right); /// /// __m128 _mm_cmpnge_ps (__m128 a, __m128 b) /// - public static Vector128 CompareNotGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareNotGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareNotGreaterThanOrEqual(left, right); /// /// __m128 _mm_cmpnlt_ps (__m128 a, __m128 b) /// - public static Vector128 CompareNotLessThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareNotLessThan(Vector128 left, Vector128 right) => CompareNotLessThan(left, right); /// /// __m128 _mm_cmpnle_ps (__m128 a, __m128 b) /// - public static Vector128 CompareNotLessThanOrEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareNotLessThanOrEqual(Vector128 left, Vector128 right) => CompareNotLessThanOrEqual(left, right); /// /// __m128 _mm_cmpord_ps (__m128 a, __m128 b) /// - public static Vector128 CompareOrdered(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareOrdered(Vector128 left, Vector128 right) => CompareOrdered(left, right); /// /// __m128 _mm_cmpunord_ps (__m128 a, __m128 b) /// - public static Vector128 CompareUnordered(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareUnordered(Vector128 left, Vector128 right) => CompareUnordered(left, right); /// /// __m128 _mm_div_ps (__m128 a, __m128 b) /// - public static Vector128 Divide(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Divide(Vector128 left, Vector128 right) => Divide(left, right); /// /// __m128 _mm_loadu_ps (float const* mem_address) /// - public static unsafe Vector128 Load(float* address) { throw new NotImplementedException(); } + public static unsafe Vector128 Load(float* address) => Load(address); /// /// __m128 _mm_load_ps (float const* mem_address) /// - public static unsafe Vector128 LoadAligned(float* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAligned(float* address) => LoadAligned(address); /// /// __m128 _mm_max_ps (__m128 a, __m128 b) /// - public static Vector128 Max(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// /// __m128 _mm_min_ps (__m128 a, __m128 b) /// - public static Vector128 Min(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// /// __m128 _mm_movehl_ps (__m128 a, __m128 b) /// - public static Vector128 MoveHighToLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 MoveHighToLow(Vector128 left, Vector128 right) => MoveHighToLow(left, right); /// /// __m128 _mm_movelh_ps (__m128 a, __m128 b) /// - public static Vector128 MoveLowToHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 MoveLowToHigh(Vector128 left, Vector128 right) => MoveLowToHigh(left, right); /// /// __m128 _mm_mul_ps (__m128 a, __m128 b) /// - public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// /// __m128 _mm_or_ps (__m128 a, __m128 b) /// - public static Vector128 Or(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// /// __m128 _mm_rcp_ps (__m128 a) /// - public static Vector128 Reciprocal(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 Reciprocal(Vector128 value) => Reciprocal(value); /// /// __m128 _mm_rsqrt_ps (__m128 a) /// - public static Vector128 ReciprocalSquareRoot(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ReciprocalSquareRoot(Vector128 value) => ReciprocalSquareRoot(value); /// /// __m128 _mm_set_ps (float e3, float e2, float e1, float e0) /// - public static Vector128 Set(float e3, float e2, float e1, float e0) { throw new NotImplementedException(); } + public static Vector128 Set(float e3, float e2, float e1, float e0) => Set(e3, e2, e1, e0); /// /// __m128 _mm_set1_ps (float a) /// - public static Vector128 Set1(float value) { throw new NotImplementedException(); } + public static Vector128 Set1(float value) => Set1(value); /// /// __m128d _mm_setzero_ps (void) /// - public static Vector128 SetZero() { throw new NotImplementedException(); } + public static Vector128 SetZero() => SetZero(); /// /// __m128 _mm_castpd_ps (__m128d a) @@ -168,51 +168,51 @@ public static class Sse /// __m128d _mm_castsi128_pd (__m128i a) /// __m128 _mm_castsi128_ps (__m128i a) /// - public static Vector128 StaticCast(Vector128 value) where T : struct where U : struct { throw new NotImplementedException(); } + public static Vector128 StaticCast(Vector128 value) where T : struct where U : struct => StaticCast(value); /// /// __m128 _mm_shuffle_ps (__m128 a, __m128 b, unsigned int control) /// - public static Vector128 Shuffle(Vector128 left, Vector128 right, byte control) { throw new NotImplementedException(); } + public static Vector128 Shuffle(Vector128 left, Vector128 right, byte control) => Shuffle(left, right, control); /// /// __m128 _mm_sqrt_ps (__m128 a) /// - public static Vector128 Sqrt(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 Sqrt(Vector128 value) => Sqrt(value); /// /// void _mm_store_ps (float* mem_addr, __m128 a) /// - public static unsafe void StoreAligned(float* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(float* address, Vector128 source) => StoreAligned(address, source); /// /// void _mm_stream_ps (float* mem_addr, __m128 a) /// - public static unsafe void StoreAlignedNonTemporal(float* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(float* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm_storeu_ps (float* mem_addr, __m128 a) /// - public static unsafe void Store(float* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void Store(float* address, Vector128 source) => Store(address, source); /// /// __m128d _mm_sub_ps (__m128d a, __m128d b) /// - public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// /// __m128 _mm_unpackhi_ps (__m128 a, __m128 b) /// - public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// /// __m128 _mm_unpacklo_ps (__m128 a, __m128 b) /// - public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// /// __m128 _mm_xor_ps (__m128 a, __m128 b) /// - public static Vector128 Xor(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs new file mode 100644 index 000000000000..64db5ca70183 --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs @@ -0,0 +1,1057 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel SSE2 hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Sse2 + { + public static bool IsSupported { get { return false; } } + + /// + /// __m128i _mm_add_epi8 (__m128i a, __m128i b) + /// + public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_add_epi8 (__m128i a, __m128i b) + /// + public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_add_epi16 (__m128i a, __m128i b) + /// + public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_add_epi16 (__m128i a, __m128i b) + /// + public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_add_epi32 (__m128i a, __m128i b) + /// + public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_add_epi32 (__m128i a, __m128i b) + /// + public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_add_epi64 (__m128i a, __m128i b) + /// + public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_add_epi64 (__m128i a, __m128i b) + /// + public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_add_pd (__m128d a, __m128d b) + /// + public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_adds_epi8 (__m128i a, __m128i b) + /// + public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_adds_epu8 (__m128i a, __m128i b) + /// + public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_adds_epi16 (__m128i a, __m128i b) + /// + public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_adds_epu16 (__m128i a, __m128i b) + /// + public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// + public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// + public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// + public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// + public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// + public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// + public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// + public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// + public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_and_pd (__m128d a, __m128d b) + /// + public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// + public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// + public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// + public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// + public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// + public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// + public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// + public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// + public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_andnot_pd (__m128d a, __m128d b) + /// + public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_avg_epu8 (__m128i a, __m128i b) + /// + public static Vector128 Average(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_avg_epu16 (__m128i a, __m128i b) + /// + public static Vector128 Average(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) + /// + public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) + /// + public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) + /// + public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) + /// + public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) + /// + public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) + /// + public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_cmpeq_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpgt_epi8 (__m128i a, __m128i b) + /// + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cmpgt_epi16 (__m128i a, __m128i b) + /// + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cmpgt_epi32 (__m128i a, __m128i b) + /// + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_cmpgt_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_cmpge_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) + /// + public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) + /// + public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) + /// + public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_cmplt_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_cmple_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_cmpneq_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_cmpngt_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareNotGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_cmpnge_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareNotGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_cmpnlt_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareNotLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_cmpnle_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareNotLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_cmpord_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareOrdered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_cmpunord_pd (__m128d a, __m128d b) + /// + public static Vector128 CompareUnordered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cvtps_epi32 (__m128 a) + /// + public static Vector128 ConvertToInt(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtpd_epi32 (__m128d a) + /// + public static Vector128 ConvertToInt(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm_cvtepi32_ps (__m128i a) + /// + public static Vector128 ConvertToFloat(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm_cvtpd_ps (__m128d a) + /// + public static Vector128 ConvertToFloat(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_cvtepi32_pd (__m128i a) + /// + public static Vector128 ConvertToDouble(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_cvtps_pd (__m128 a) + /// + public static Vector128 ConvertToDouble(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cvttps_epi32 (__m128 a) + /// + public static Vector128 ConvertToIntWithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvttpd_epi32 (__m128d a) + /// + public static Vector128 ConvertToIntWithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_div_pd (__m128d a, __m128d b) + /// + public static Vector128 Divide(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_extract_epi16 (__m128i a, int immediate) + /// + public static short ExtractShort(Vector128 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// int _mm_extract_epi16 (__m128i a, int immediate) + /// + public static ushort ExtractUshort(Vector128 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) + /// + public static Vector128 InsertShort(Vector128 value, short data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) + /// + public static Vector128 InsertUshort(Vector128 value, ushort data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 Load(sbyte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 Load(byte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 Load(short* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 Load(ushort* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 Load(int* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 Load(uint* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 Load(long* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 Load(ulong* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_loadu_pd (double const* mem_address) + /// + public static unsafe Vector128 Load(double* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 LoadAligned(sbyte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 LoadAligned(byte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 LoadAligned(short* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 LoadAligned(ushort* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 LoadAligned(int* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 LoadAligned(uint* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 LoadAligned(long* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// + public static unsafe Vector128 LoadAligned(ulong* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_load_pd (double const* mem_address) + /// + public static unsafe Vector128 LoadAligned(double* address) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) + /// + public static unsafe void MaskMove(Vector128 source, Vector128 mask, sbyte* address) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) + /// + public static unsafe void MaskMove(Vector128 source, Vector128 mask, byte* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_max_epu8 (__m128i a, __m128i b) + /// + public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_max_epi16 (__m128i a, __m128i b) + /// + public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_max_pd (__m128d a, __m128d b) + /// + public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_min_epu8 (__m128i a, __m128i b) + /// + public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_min_epi16 (__m128i a, __m128i b) + /// + public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_min_pd (__m128d a, __m128d b) + /// + public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_movemask_epi8 (__m128i a) + /// + public static int MoveMask(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// int _mm_movemask_pd (__m128d a) + /// + public static int MoveMask(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_mul_epu32 (__m128i a, __m128i b) + /// + public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_mul_pd (__m128d a, __m128d b) + /// + public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_mulhi_epi16 (__m128i a, __m128i b) + /// + public static Vector128 MultiplyHi(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_mulhi_epu16 (__m128i a, __m128i b) + /// + public static Vector128 MultiplyHi(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_madd_epi16 (__m128i a, __m128i b) + /// + public static Vector128 MultiplyHorizontalAdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b) + /// + public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// + public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// + public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// + public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// + public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// + public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// + public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// + public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// + public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_or_pd (__m128d a, __m128d b) + /// + public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_packs_epi16 (__m128i a, __m128i b) + /// + public static Vector128 PackSignedSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_packs_epi32 (__m128i a, __m128i b) + /// + public static Vector128 PackSignedSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_packus_epi16 (__m128i a, __m128i b) + /// + public static Vector128 PackUnsignedSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// ___m128i _mm_set_epi8 (char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0) + /// + public static Vector128 Set(sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) { throw new PlatformNotSupportedException(); } + /// + /// ___m128i _mm_set_epi8 (char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0) + /// + public static Vector128 Set(byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set_epi16 (short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) + /// + public static Vector128 Set(short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set_epi16 (short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) + /// + public static Vector128 Set(ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set_epi32 (int e3, int e2, int e1, int e0) + /// + public static Vector128 Set(int e3, int e2, int e1, int e0) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set_epi32 (int e3, int e2, int e1, int e0) + /// + public static Vector128 Set(uint e3, uint e2, uint e1, uint e0) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set_epi64x (__int64 e1, __int64 e0) + /// + public static Vector128 Set(long e1, long e0) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set_epi64x (__int64 e1, __int64 e0) + /// + public static Vector128 Set(ulong e1, ulong e0) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_set_pd (double e1, double e0) + /// + public static Vector128 Set(double e1, double e0) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_set1_epi8 (char a) + /// + public static Vector128 Set1(byte value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set1_epi8 (char a) + /// + public static Vector128 Set1(sbyte value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set1_epi16 (short a) + /// + public static Vector128 Set1(short value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set1_epi16 (short a) + /// + public static Vector128 Set1(ushort value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set1_epi32 (int a) + /// + public static Vector128 Set1(int value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set1_epi32 (int a) + /// + public static Vector128 Set1(uint value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set1_epi64x (long long a) + /// + public static Vector128 Set1(long value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_set1_epi64x (long long a) + /// + public static Vector128 Set1(ulong value) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_set1_pd (double a) + /// + public static Vector128 Set1(double value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_setzero_si128 () + /// __m128d _mm_setzero_pd (void) + /// + public static Vector128 SetZero() where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_sad_epu8 (__m128i a, __m128i b) + /// + public static Vector128 SumAbsoluteDifferences(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) + /// + public static Vector128 Shuffle(Vector128 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) + /// + public static Vector128 Shuffle(Vector128 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_shuffle_pd (__m128d a, __m128d b, int immediate) + /// + public static Vector128 Shuffle(Vector128 left, Vector128 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_shufflehi_epi16 (__m128i a, int immediate) + /// + public static Vector128 ShuffleHigh(Vector128 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_shufflehi_epi16 (__m128i a, int control) + /// + public static Vector128 ShuffleHigh(Vector128 value, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) + /// + public static Vector128 ShuffleLow(Vector128 value, byte control) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) + /// + public static Vector128 ShuffleLow(Vector128 value, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_slli_epi16 (__m128i a, int immediate) + /// + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_slli_epi16 (__m128i a, int immediate) + /// + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_slli_epi32 (__m128i a, int immediate) + /// + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_slli_epi32 (__m128i a, int immediate) + /// + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_slli_epi64 (__m128i a, int immediate) + /// + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_slli_epi64 (__m128i a, int immediate) + /// + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_srai_epi16 (__m128i a, int immediate) + /// + public static Vector128 ShiftRightArithmetic(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_srai_epi32 (__m128i a, int immediate) + /// + public static Vector128 ShiftRightArithmetic(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_srli_epi16 (__m128i a, int immediate) + /// + public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_srli_epi16 (__m128i a, int immediate) + /// + public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_srli_epi32 (__m128i a, int immediate) + /// + public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_srli_epi32 (__m128i a, int immediate) + /// + public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_srli_epi64 (__m128i a, int immediate) + /// + public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_srli_epi64 (__m128i a, int immediate) + /// + public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_sqrt_pd (__m128d a) + /// + public static Vector128 Sqrt(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAligned(sbyte* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAligned(byte* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAligned(short* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAligned(ushort* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAligned(int* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAligned(uint* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAligned(long* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAligned(ulong* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_store_pd (double* mem_addr, __m128d a) + /// + public static unsafe void StoreAligned(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAlignedNonTemporal(short* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAlignedNonTemporal(int* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAlignedNonTemporal(long* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_stream_pd (double* mem_addr, __m128d a) + /// + public static unsafe void StoreAlignedNonTemporal(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void Store(sbyte* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void Store(byte* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void Store(short* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void Store(ushort* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void Store(int* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void Store(uint* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void Store(long* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void Store(ulong* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_storeu_pd (double* mem_addr, __m128d a) + /// + public static unsafe void Store(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_storeh_pd (double* mem_addr, __m128d a) + /// + public static unsafe void StoreHigh(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreLow(long* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) + /// + public static unsafe void StoreLow(ulong* address, Vector128 source) { throw new PlatformNotSupportedException(); } + /// + /// void _mm_storel_pd (double* mem_addr, __m128d a) + /// + public static unsafe void StoreLow(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) + /// + public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) + /// + public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) + /// + public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) + /// + public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) + /// + public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) + /// + public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) + /// + public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) + /// + public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_sub_pd (__m128d a, __m128d b) + /// + public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_subs_epi8 (__m128i a, __m128i b) + /// + public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_subs_epi16 (__m128i a, __m128i b) + /// + public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_subs_epu8 (__m128i a, __m128i b) + /// + public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_subs_epu16 (__m128i a, __m128i b) + /// + public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) + /// + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) + /// + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) + /// + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) + /// UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) + /// + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) + /// + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) + /// + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) + /// + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_unpackhi_pd (__m128d a, __m128d b) + /// + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) + /// + public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) + /// + public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) + /// + public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) + /// + public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) + /// + public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) + /// + public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) + /// + public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) + /// + public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_unpacklo_pd (__m128d a, __m128d b) + /// + public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// + public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// + public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// + public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// + public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// + public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// + public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// + public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// + public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_xor_pd (__m128d a, __m128d b) + /// + public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.cs index ffe35f883cd8..fef550741cfa 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.cs @@ -13,1045 +13,1045 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Sse2 { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// __m128i _mm_add_epi8 (__m128i a, __m128i b) /// - public static Vector128 Add(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// /// __m128i _mm_add_epi8 (__m128i a, __m128i b) /// - public static Vector128 Add(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// /// __m128i _mm_add_epi16 (__m128i a, __m128i b) /// - public static Vector128 Add(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// /// __m128i _mm_add_epi16 (__m128i a, __m128i b) /// - public static Vector128 Add(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// /// __m128i _mm_add_epi32 (__m128i a, __m128i b) /// - public static Vector128 Add(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// /// __m128i _mm_add_epi32 (__m128i a, __m128i b) /// - public static Vector128 Add(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// /// __m128i _mm_add_epi64 (__m128i a, __m128i b) /// - public static Vector128 Add(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// /// __m128i _mm_add_epi64 (__m128i a, __m128i b) /// - public static Vector128 Add(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// /// __m128d _mm_add_pd (__m128d a, __m128d b) /// - public static Vector128 Add(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// /// __m128i _mm_adds_epi8 (__m128i a, __m128i b) /// - public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// /// __m128i _mm_adds_epu8 (__m128i a, __m128i b) /// - public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// /// __m128i _mm_adds_epi16 (__m128i a, __m128i b) /// - public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// /// __m128i _mm_adds_epu16 (__m128i a, __m128i b) /// - public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// /// __m128i _mm_and_si128 (__m128i a, __m128i b) /// - public static Vector128 And(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// /// __m128i _mm_and_si128 (__m128i a, __m128i b) /// - public static Vector128 And(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// /// __m128i _mm_and_si128 (__m128i a, __m128i b) /// - public static Vector128 And(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// /// __m128i _mm_and_si128 (__m128i a, __m128i b) /// - public static Vector128 And(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// /// __m128i _mm_and_si128 (__m128i a, __m128i b) /// - public static Vector128 And(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// /// __m128i _mm_and_si128 (__m128i a, __m128i b) /// - public static Vector128 And(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// /// __m128i _mm_and_si128 (__m128i a, __m128i b) /// - public static Vector128 And(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// /// __m128i _mm_and_si128 (__m128i a, __m128i b) /// - public static Vector128 And(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// /// __m128d _mm_and_pd (__m128d a, __m128d b) /// - public static Vector128 And(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) /// - public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) /// - public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) /// - public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) /// - public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) /// - public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) /// - public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) /// - public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) /// - public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// /// __m128d _mm_andnot_pd (__m128d a, __m128d b) /// - public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// /// __m128i _mm_avg_epu8 (__m128i a, __m128i b) /// - public static Vector128 Average(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Average(Vector128 left, Vector128 right) => Average(left, right); /// /// __m128i _mm_avg_epu16 (__m128i a, __m128i b) /// - public static Vector128 Average(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Average(Vector128 left, Vector128 right) => Average(left, right); /// /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) /// - public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) /// - public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) /// - public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) /// - public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) /// - public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) /// - public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// /// __m128d _mm_cmpeq_pd (__m128d a, __m128d b) /// - public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// /// __m128i _mm_cmpgt_epi8 (__m128i a, __m128i b) /// - public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// /// __m128i _mm_cmpgt_epi16 (__m128i a, __m128i b) /// - public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// /// __m128i _mm_cmpgt_epi32 (__m128i a, __m128i b) /// - public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// /// __m128d _mm_cmpgt_pd (__m128d a, __m128d b) /// - public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// /// __m128d _mm_cmpge_pd (__m128d a, __m128d b) /// - public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) /// - public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) /// - public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) /// - public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// /// __m128d _mm_cmplt_pd (__m128d a, __m128d b) /// - public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// /// __m128d _mm_cmple_pd (__m128d a, __m128d b) /// - public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// /// __m128d _mm_cmpneq_pd (__m128d a, __m128d b) /// - public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// /// __m128d _mm_cmpngt_pd (__m128d a, __m128d b) /// - public static Vector128 CompareNotGreaterThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareNotGreaterThan(Vector128 left, Vector128 right) => CompareNotGreaterThan(left, right); /// /// __m128d _mm_cmpnge_pd (__m128d a, __m128d b) /// - public static Vector128 CompareNotGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareNotGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareNotGreaterThanOrEqual(left, right); /// /// __m128d _mm_cmpnlt_pd (__m128d a, __m128d b) /// - public static Vector128 CompareNotLessThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareNotLessThan(Vector128 left, Vector128 right) => CompareNotLessThan(left, right); /// /// __m128d _mm_cmpnle_pd (__m128d a, __m128d b) /// - public static Vector128 CompareNotLessThanOrEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareNotLessThanOrEqual(Vector128 left, Vector128 right) => CompareNotLessThanOrEqual(left, right); /// /// __m128d _mm_cmpord_pd (__m128d a, __m128d b) /// - public static Vector128 CompareOrdered(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareOrdered(Vector128 left, Vector128 right) => CompareOrdered(left, right); /// /// __m128d _mm_cmpunord_pd (__m128d a, __m128d b) /// - public static Vector128 CompareUnordered(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareUnordered(Vector128 left, Vector128 right) => CompareUnordered(left, right); /// /// __m128i _mm_cvtps_epi32 (__m128 a) /// - public static Vector128 ConvertToInt(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToInt(Vector128 value) => ConvertToInt(value); /// /// __m128i _mm_cvtpd_epi32 (__m128d a) /// - public static Vector128 ConvertToInt(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToInt(Vector128 value) => ConvertToInt(value); /// /// __m128 _mm_cvtepi32_ps (__m128i a) /// - public static Vector128 ConvertToFloat(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToFloat(Vector128 value) => ConvertToFloat(value); /// /// __m128 _mm_cvtpd_ps (__m128d a) /// - public static Vector128 ConvertToFloat(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToFloat(Vector128 value) => ConvertToFloat(value); /// /// __m128d _mm_cvtepi32_pd (__m128i a) /// - public static Vector128 ConvertToDouble(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToDouble(Vector128 value) => ConvertToDouble(value); /// /// __m128d _mm_cvtps_pd (__m128 a) /// - public static Vector128 ConvertToDouble(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToDouble(Vector128 value) => ConvertToDouble(value); /// /// __m128i _mm_cvttps_epi32 (__m128 a) /// - public static Vector128 ConvertToIntWithTruncation(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToIntWithTruncation(Vector128 value) => ConvertToIntWithTruncation(value); /// /// __m128i _mm_cvttpd_epi32 (__m128d a) /// - public static Vector128 ConvertToIntWithTruncation(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToIntWithTruncation(Vector128 value) => ConvertToIntWithTruncation(value); /// /// __m128d _mm_div_pd (__m128d a, __m128d b) /// - public static Vector128 Divide(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Divide(Vector128 left, Vector128 right) => Divide(left, right); /// /// int _mm_extract_epi16 (__m128i a, int immediate) /// - public static short ExtractShort(Vector128 value, byte index) where T : struct { throw new NotImplementedException(); } + public static short ExtractShort(Vector128 value, byte index) where T : struct => ExtractShort(value, index); /// /// int _mm_extract_epi16 (__m128i a, int immediate) /// - public static ushort ExtractUshort(Vector128 value, byte index) where T : struct { throw new NotImplementedException(); } + public static ushort ExtractUshort(Vector128 value, byte index) where T : struct => ExtractUshort(value, index); /// /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) /// - public static Vector128 InsertShort(Vector128 value, short data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector128 InsertShort(Vector128 value, short data, byte index) where T : struct => InsertShort(value, data, index); /// /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) /// - public static Vector128 InsertUshort(Vector128 value, ushort data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector128 InsertUshort(Vector128 value, ushort data, byte index) where T : struct => InsertUshort(value, data, index); /// /// __m128i _mm_loadu_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 Load(sbyte* address) { throw new NotImplementedException(); } + public static unsafe Vector128 Load(sbyte* address) => Load(address); /// /// __m128i _mm_loadu_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 Load(byte* address) { throw new NotImplementedException(); } + public static unsafe Vector128 Load(byte* address) => Load(address); /// /// __m128i _mm_loadu_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 Load(short* address) { throw new NotImplementedException(); } + public static unsafe Vector128 Load(short* address) => Load(address); /// /// __m128i _mm_loadu_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 Load(ushort* address) { throw new NotImplementedException(); } + public static unsafe Vector128 Load(ushort* address) => Load(address); /// /// __m128i _mm_loadu_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 Load(int* address) { throw new NotImplementedException(); } + public static unsafe Vector128 Load(int* address) => Load(address); /// /// __m128i _mm_loadu_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 Load(uint* address) { throw new NotImplementedException(); } + public static unsafe Vector128 Load(uint* address) => Load(address); /// /// __m128i _mm_loadu_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 Load(long* address) { throw new NotImplementedException(); } + public static unsafe Vector128 Load(long* address) => Load(address); /// /// __m128i _mm_loadu_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 Load(ulong* address) { throw new NotImplementedException(); } + public static unsafe Vector128 Load(ulong* address) => Load(address); /// /// __m128d _mm_loadu_pd (double const* mem_address) /// - public static unsafe Vector128 Load(double* address) { throw new NotImplementedException(); } + public static unsafe Vector128 Load(double* address) => Load(address); /// /// __m128i _mm_load_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 LoadAligned(sbyte* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAligned(sbyte* address) => LoadAligned(address); /// /// __m128i _mm_load_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 LoadAligned(byte* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAligned(byte* address) => LoadAligned(address); /// /// __m128i _mm_load_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 LoadAligned(short* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAligned(short* address) => LoadAligned(address); /// /// __m128i _mm_load_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 LoadAligned(ushort* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAligned(ushort* address) => LoadAligned(address); /// /// __m128i _mm_load_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 LoadAligned(int* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAligned(int* address) => LoadAligned(address); /// /// __m128i _mm_load_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 LoadAligned(uint* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAligned(uint* address) => LoadAligned(address); /// /// __m128i _mm_load_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 LoadAligned(long* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAligned(long* address) => LoadAligned(address); /// /// __m128i _mm_load_si128 (__m128i const* mem_address) /// - public static unsafe Vector128 LoadAligned(ulong* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAligned(ulong* address) => LoadAligned(address); /// /// __m128d _mm_load_pd (double const* mem_address) /// - public static unsafe Vector128 LoadAligned(double* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAligned(double* address) => LoadAligned(address); /// /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) /// - public static unsafe void MaskMove(Vector128 source, Vector128 mask, sbyte* address) { throw new NotImplementedException(); } + public static unsafe void MaskMove(Vector128 source, Vector128 mask, sbyte* address) => MaskMove(source, mask, address); /// /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) /// - public static unsafe void MaskMove(Vector128 source, Vector128 mask, byte* address) { throw new NotImplementedException(); } + public static unsafe void MaskMove(Vector128 source, Vector128 mask, byte* address) => MaskMove(source, mask, address); /// /// __m128i _mm_max_epu8 (__m128i a, __m128i b) /// - public static Vector128 Max(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// /// __m128i _mm_max_epi16 (__m128i a, __m128i b) /// - public static Vector128 Max(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// /// __m128d _mm_max_pd (__m128d a, __m128d b) /// - public static Vector128 Max(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// /// __m128i _mm_min_epu8 (__m128i a, __m128i b) /// - public static Vector128 Min(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// /// __m128i _mm_min_epi16 (__m128i a, __m128i b) /// - public static Vector128 Min(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// /// __m128d _mm_min_pd (__m128d a, __m128d b) /// - public static Vector128 Min(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// /// int _mm_movemask_epi8 (__m128i a) /// - public static int MoveMask(Vector128 value) { throw new NotImplementedException(); } + public static int MoveMask(Vector128 value) => MoveMask(value); /// /// int _mm_movemask_pd (__m128d a) /// - public static int MoveMask(Vector128 value) { throw new NotImplementedException(); } + public static int MoveMask(Vector128 value) => MoveMask(value); /// /// __m128i _mm_mul_epu32 (__m128i a, __m128i b) /// - public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// /// __m128d _mm_mul_pd (__m128d a, __m128d b) /// - public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// /// __m128i _mm_mulhi_epi16 (__m128i a, __m128i b) /// - public static Vector128 MultiplyHi(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 MultiplyHi(Vector128 left, Vector128 right) => MultiplyHi(left, right); /// /// __m128i _mm_mulhi_epu16 (__m128i a, __m128i b) /// - public static Vector128 MultiplyHi(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 MultiplyHi(Vector128 left, Vector128 right) => MultiplyHi(left, right); /// /// __m128i _mm_madd_epi16 (__m128i a, __m128i b) /// - public static Vector128 MultiplyHorizontalAdd(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 MultiplyHorizontalAdd(Vector128 left, Vector128 right) => MultiplyHorizontalAdd(left, right); /// /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b) /// - public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 MultiplyLow(Vector128 left, Vector128 right) => MultiplyLow(left, right); /// /// __m128i _mm_or_si128 (__m128i a, __m128i b) /// - public static Vector128 Or(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// /// __m128i _mm_or_si128 (__m128i a, __m128i b) /// - public static Vector128 Or(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// /// __m128i _mm_or_si128 (__m128i a, __m128i b) /// - public static Vector128 Or(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// /// __m128i _mm_or_si128 (__m128i a, __m128i b) /// - public static Vector128 Or(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// /// __m128i _mm_or_si128 (__m128i a, __m128i b) /// - public static Vector128 Or(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// /// __m128i _mm_or_si128 (__m128i a, __m128i b) /// - public static Vector128 Or(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// /// __m128i _mm_or_si128 (__m128i a, __m128i b) /// - public static Vector128 Or(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// /// __m128i _mm_or_si128 (__m128i a, __m128i b) /// - public static Vector128 Or(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// /// __m128d _mm_or_pd (__m128d a, __m128d b) /// - public static Vector128 Or(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// /// __m128i _mm_packs_epi16 (__m128i a, __m128i b) /// - public static Vector128 PackSignedSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 PackSignedSaturate(Vector128 left, Vector128 right) => PackSignedSaturate(left, right); /// /// __m128i _mm_packs_epi32 (__m128i a, __m128i b) /// - public static Vector128 PackSignedSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 PackSignedSaturate(Vector128 left, Vector128 right) => PackSignedSaturate(left, right); /// /// __m128i _mm_packus_epi16 (__m128i a, __m128i b) /// - public static Vector128 PackUnsignedSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 PackUnsignedSaturate(Vector128 left, Vector128 right) => PackUnsignedSaturate(left, right); /// /// ___m128i _mm_set_epi8 (char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0) /// - public static Vector128 Set(sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) { throw new NotImplementedException(); } + public static Vector128 Set(sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) => Set(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0); /// /// ___m128i _mm_set_epi8 (char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0) /// - public static Vector128 Set(byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) { throw new NotImplementedException(); } + public static Vector128 Set(byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) => Set(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0); /// /// __m128i _mm_set_epi16 (short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) /// - public static Vector128 Set(short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) { throw new NotImplementedException(); } + public static Vector128 Set(short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) => Set(e7, e6, e5, e4, e3, e2, e1, e0); /// /// __m128i _mm_set_epi16 (short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) /// - public static Vector128 Set(ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) { throw new NotImplementedException(); } + public static Vector128 Set(ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) => Set(e7, e6, e5, e4, e3, e2, e1, e0); /// /// __m128i _mm_set_epi32 (int e3, int e2, int e1, int e0) /// - public static Vector128 Set(int e3, int e2, int e1, int e0) { throw new NotImplementedException(); } + public static Vector128 Set(int e3, int e2, int e1, int e0) => Set(e3, e2, e1, e0); /// /// __m128i _mm_set_epi32 (int e3, int e2, int e1, int e0) /// - public static Vector128 Set(uint e3, uint e2, uint e1, uint e0) { throw new NotImplementedException(); } + public static Vector128 Set(uint e3, uint e2, uint e1, uint e0) => Set(e3, e2, e1, e0); /// /// __m128i _mm_set_epi64x (__int64 e1, __int64 e0) /// - public static Vector128 Set(long e1, long e0) { throw new NotImplementedException(); } + public static Vector128 Set(long e1, long e0) => Set(e1, e0); /// /// __m128i _mm_set_epi64x (__int64 e1, __int64 e0) /// - public static Vector128 Set(ulong e1, ulong e0) { throw new NotImplementedException(); } + public static Vector128 Set(ulong e1, ulong e0) => Set(e1, e0); /// /// __m128d _mm_set_pd (double e1, double e0) /// - public static Vector128 Set(double e1, double e0) { throw new NotImplementedException(); } + public static Vector128 Set(double e1, double e0) => Set(e1, e0); /// /// __m128i _mm_set1_epi8 (char a) /// - public static Vector128 Set1(byte value) { throw new NotImplementedException(); } + public static Vector128 Set1(byte value) => Set1(value); /// /// __m128i _mm_set1_epi8 (char a) /// - public static Vector128 Set1(sbyte value) { throw new NotImplementedException(); } + public static Vector128 Set1(sbyte value) => Set1(value); /// /// __m128i _mm_set1_epi16 (short a) /// - public static Vector128 Set1(short value) { throw new NotImplementedException(); } + public static Vector128 Set1(short value) => Set1(value); /// /// __m128i _mm_set1_epi16 (short a) /// - public static Vector128 Set1(ushort value) { throw new NotImplementedException(); } + public static Vector128 Set1(ushort value) => Set1(value); /// /// __m128i _mm_set1_epi32 (int a) /// - public static Vector128 Set1(int value) { throw new NotImplementedException(); } + public static Vector128 Set1(int value) => Set1(value); /// /// __m128i _mm_set1_epi32 (int a) /// - public static Vector128 Set1(uint value) { throw new NotImplementedException(); } + public static Vector128 Set1(uint value) => Set1(value); /// /// __m128i _mm_set1_epi64x (long long a) /// - public static Vector128 Set1(long value) { throw new NotImplementedException(); } + public static Vector128 Set1(long value) => Set1(value); /// /// __m128i _mm_set1_epi64x (long long a) /// - public static Vector128 Set1(ulong value) { throw new NotImplementedException(); } + public static Vector128 Set1(ulong value) => Set1(value); /// /// __m128d _mm_set1_pd (double a) /// - public static Vector128 Set1(double value) { throw new NotImplementedException(); } + public static Vector128 Set1(double value) => Set1(value); /// /// __m128i _mm_setzero_si128 () /// __m128d _mm_setzero_pd (void) /// - public static Vector128 SetZero() where T : struct { throw new NotImplementedException(); } + public static Vector128 SetZero() where T : struct => SetZero(); /// /// __m128i _mm_sad_epu8 (__m128i a, __m128i b) /// - public static Vector128 SumAbsoluteDifferences(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 SumAbsoluteDifferences(Vector128 left, Vector128 right) => SumAbsoluteDifferences(left, right); /// /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) /// - public static Vector128 Shuffle(Vector128 value, byte control) { throw new NotImplementedException(); } + public static Vector128 Shuffle(Vector128 value, byte control) => Shuffle(value, control); /// /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) /// - public static Vector128 Shuffle(Vector128 value, byte control) { throw new NotImplementedException(); } + public static Vector128 Shuffle(Vector128 value, byte control) => Shuffle(value, control); /// /// __m128d _mm_shuffle_pd (__m128d a, __m128d b, int immediate) /// - public static Vector128 Shuffle(Vector128 left, Vector128 right, byte control) { throw new NotImplementedException(); } + public static Vector128 Shuffle(Vector128 left, Vector128 right, byte control) => Shuffle(left, right, control); /// /// __m128i _mm_shufflehi_epi16 (__m128i a, int immediate) /// - public static Vector128 ShuffleHigh(Vector128 value, byte control) { throw new NotImplementedException(); } + public static Vector128 ShuffleHigh(Vector128 value, byte control) => ShuffleHigh(value, control); /// /// __m128i _mm_shufflehi_epi16 (__m128i a, int control) /// - public static Vector128 ShuffleHigh(Vector128 value, byte control) { throw new NotImplementedException(); } + public static Vector128 ShuffleHigh(Vector128 value, byte control) => ShuffleHigh(value, control); /// /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) /// - public static Vector128 ShuffleLow(Vector128 value, byte control) { throw new NotImplementedException(); } + public static Vector128 ShuffleLow(Vector128 value, byte control) => ShuffleLow(value, control); /// /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) /// - public static Vector128 ShuffleLow(Vector128 value, byte control) { throw new NotImplementedException(); } + public static Vector128 ShuffleLow(Vector128 value, byte control) => ShuffleLow(value, control); /// /// __m128i _mm_slli_epi16 (__m128i a, int immediate) /// - public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) => ShiftLeftLogical(value, count); /// /// __m128i _mm_slli_epi16 (__m128i a, int immediate) /// - public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) => ShiftLeftLogical(value, count); /// /// __m128i _mm_slli_epi32 (__m128i a, int immediate) /// - public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) => ShiftLeftLogical(value, count); /// /// __m128i _mm_slli_epi32 (__m128i a, int immediate) /// - public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) => ShiftLeftLogical(value, count); /// /// __m128i _mm_slli_epi64 (__m128i a, int immediate) /// - public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) => ShiftLeftLogical(value, count); /// /// __m128i _mm_slli_epi64 (__m128i a, int immediate) /// - public static Vector128 ShiftLeftLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical(Vector128 value, byte count) => ShiftLeftLogical(value, count); /// /// __m128i _mm_bslli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m128i _mm_bslli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m128i _mm_bslli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m128i _mm_bslli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m128i _mm_bslli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m128i _mm_bslli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m128i _mm_bslli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m128i _mm_bslli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// /// __m128i _mm_srai_epi16 (__m128i a, int immediate) /// - public static Vector128 ShiftRightArithmetic(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftRightArithmetic(Vector128 value, byte count) => ShiftRightArithmetic(value, count); /// /// __m128i _mm_srai_epi32 (__m128i a, int immediate) /// - public static Vector128 ShiftRightArithmetic(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftRightArithmetic(Vector128 value, byte count) => ShiftRightArithmetic(value, count); /// /// __m128i _mm_srli_epi16 (__m128i a, int immediate) /// - public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical(Vector128 value, byte count) => ShiftRightLogical(value, count); /// /// __m128i _mm_srli_epi16 (__m128i a, int immediate) /// - public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical(Vector128 value, byte count) => ShiftRightLogical(value, count); /// /// __m128i _mm_srli_epi32 (__m128i a, int immediate) /// - public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical(Vector128 value, byte count) => ShiftRightLogical(value, count); /// /// __m128i _mm_srli_epi32 (__m128i a, int immediate) /// - public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical(Vector128 value, byte count) => ShiftRightLogical(value, count); /// /// __m128i _mm_srli_epi64 (__m128i a, int immediate) /// - public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical(Vector128 value, byte count) => ShiftRightLogical(value, count); /// /// __m128i _mm_srli_epi64 (__m128i a, int immediate) /// - public static Vector128 ShiftRightLogical(Vector128 value, byte count) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical(Vector128 value, byte count) => ShiftRightLogical(value, count); /// /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) /// - public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) { throw new NotImplementedException(); } + public static Vector128 ShiftRightLogical128BitLane(Vector128 value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// /// __m128d _mm_sqrt_pd (__m128d a) /// - public static Vector128 Sqrt(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 Sqrt(Vector128 value) => Sqrt(value); /// /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAligned(sbyte* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(sbyte* address, Vector128 source) => StoreAligned(address, source); /// /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAligned(byte* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(byte* address, Vector128 source) => StoreAligned(address, source); /// /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAligned(short* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(short* address, Vector128 source) => StoreAligned(address, source); /// /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAligned(ushort* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(ushort* address, Vector128 source) => StoreAligned(address, source); /// /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAligned(int* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(int* address, Vector128 source) => StoreAligned(address, source); /// /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAligned(uint* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(uint* address, Vector128 source) => StoreAligned(address, source); /// /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAligned(long* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(long* address, Vector128 source) => StoreAligned(address, source); /// /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAligned(ulong* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(ulong* address, Vector128 source) => StoreAligned(address, source); /// /// void _mm_store_pd (double* mem_addr, __m128d a) /// - public static unsafe void StoreAligned(double* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAligned(double* address, Vector128 source) => StoreAligned(address, source); /// /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAlignedNonTemporal(short* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(short* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAlignedNonTemporal(int* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(int* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAlignedNonTemporal(long* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(long* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm_stream_pd (double* mem_addr, __m128d a) /// - public static unsafe void StoreAlignedNonTemporal(double* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreAlignedNonTemporal(double* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void Store(sbyte* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void Store(sbyte* address, Vector128 source) => Store(address, source); /// /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void Store(byte* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void Store(byte* address, Vector128 source) => Store(address, source); /// /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void Store(short* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void Store(short* address, Vector128 source) => Store(address, source); /// /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void Store(ushort* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void Store(ushort* address, Vector128 source) => Store(address, source); /// /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void Store(int* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void Store(int* address, Vector128 source) => Store(address, source); /// /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void Store(uint* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void Store(uint* address, Vector128 source) => Store(address, source); /// /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void Store(long* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void Store(long* address, Vector128 source) => Store(address, source); /// /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) /// - public static unsafe void Store(ulong* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void Store(ulong* address, Vector128 source) => Store(address, source); /// /// void _mm_storeu_pd (double* mem_addr, __m128d a) /// - public static unsafe void Store(double* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void Store(double* address, Vector128 source) => Store(address, source); /// /// void _mm_storeh_pd (double* mem_addr, __m128d a) /// - public static unsafe void StoreHigh(double* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreHigh(double* address, Vector128 source) => StoreHigh(address, source); /// /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreLow(long* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreLow(long* address, Vector128 source) => StoreLow(address, source); /// /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) /// - public static unsafe void StoreLow(ulong* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreLow(ulong* address, Vector128 source) => StoreLow(address, source); /// /// void _mm_storel_pd (double* mem_addr, __m128d a) /// - public static unsafe void StoreLow(double* address, Vector128 source) { throw new NotImplementedException(); } + public static unsafe void StoreLow(double* address, Vector128 source) => StoreLow(address, source); /// /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) /// - public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) /// - public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) /// - public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) /// - public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) /// - public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) /// - public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) /// - public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) /// - public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// /// __m128d _mm_sub_pd (__m128d a, __m128d b) /// - public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// /// __m128i _mm_subs_epi8 (__m128i a, __m128i b) /// - public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// /// __m128i _mm_subs_epi16 (__m128i a, __m128i b) /// - public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// /// __m128i _mm_subs_epu8 (__m128i a, __m128i b) /// - public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// /// __m128i _mm_subs_epu16 (__m128i a, __m128i b) /// - public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) /// - public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) /// - public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) /// - public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) /// UnpackHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) /// - public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) /// - public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) /// - public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) /// - public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// /// __m128d _mm_unpackhi_pd (__m128d a, __m128d b) /// - public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) /// - public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) /// - public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) /// - public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) /// - public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) /// - public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) /// - public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) /// - public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) /// - public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// /// __m128d _mm_unpacklo_pd (__m128d a, __m128d b) /// - public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// /// __m128i _mm_xor_si128 (__m128i a, __m128i b) /// - public static Vector128 Xor(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// /// __m128i _mm_xor_si128 (__m128i a, __m128i b) /// - public static Vector128 Xor(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// /// __m128i _mm_xor_si128 (__m128i a, __m128i b) /// - public static Vector128 Xor(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// /// __m128i _mm_xor_si128 (__m128i a, __m128i b) /// - public static Vector128 Xor(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// /// __m128i _mm_xor_si128 (__m128i a, __m128i b) /// - public static Vector128 Xor(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// /// __m128i _mm_xor_si128 (__m128i a, __m128i b) /// - public static Vector128 Xor(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// /// __m128i _mm_xor_si128 (__m128i a, __m128i b) /// - public static Vector128 Xor(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// /// __m128i _mm_xor_si128 (__m128i a, __m128i b) /// - public static Vector128 Xor(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// /// __m128d _mm_xor_pd (__m128d a, __m128d b) /// - public static Vector128 Xor(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs new file mode 100644 index 000000000000..24b9c246f667 --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs @@ -0,0 +1,78 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel SSE3 hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Sse3 + { + public static bool IsSupported { get { return false; } } + + /// + /// __m128 _mm_addsub_ps (__m128 a, __m128 b) + /// + public static Vector128 AddSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_addsub_pd (__m128d a, __m128d b) + /// + public static Vector128 AddSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_hadd_ps (__m128 a, __m128 b) + /// + public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_hadd_pd (__m128d a, __m128d b) + /// + public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_hsub_ps (__m128 a, __m128 b) + /// + public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_hsub_pd (__m128d a, __m128d b) + /// + public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_loaddup_pd (double const* mem_addr) + /// + public static unsafe Vector128 LoadAndDuplicate(double* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// + public static unsafe Vector128 LoadDqu(sbyte* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadDqu(byte* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadDqu(short* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadDqu(ushort* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadDqu(int* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadDqu(uint* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadDqu(long* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadDqu(ulong* address) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_movedup_pd (__m128d a) + /// + public static Vector128 MoveAndDuplicate(Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_movehdup_ps (__m128 a) + /// + public static Vector128 MoveHighAndDuplicate(Vector128 source) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_moveldup_ps (__m128 a) + /// + public static Vector128 MoveLowAndDuplicate(Vector128 source) { throw new PlatformNotSupportedException(); } + + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse3.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse3.cs index 5e4ac9dd0ee2..0c9fb5b22916 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse3.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse3.cs @@ -13,66 +13,66 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Sse3 { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// __m128 _mm_addsub_ps (__m128 a, __m128 b) /// - public static Vector128 AddSubtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AddSubtract(Vector128 left, Vector128 right) => AddSubtract(left, right); /// /// __m128d _mm_addsub_pd (__m128d a, __m128d b) /// - public static Vector128 AddSubtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 AddSubtract(Vector128 left, Vector128 right) => AddSubtract(left, right); /// /// __m128 _mm_hadd_ps (__m128 a, __m128 b) /// - public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) => HorizontalAdd(left, right); /// /// __m128d _mm_hadd_pd (__m128d a, __m128d b) /// - public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) => HorizontalAdd(left, right); /// /// __m128 _mm_hsub_ps (__m128 a, __m128 b) /// - public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) => HorizontalSubtract(left, right); /// /// __m128d _mm_hsub_pd (__m128d a, __m128d b) /// - public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) => HorizontalSubtract(left, right); /// /// __m128d _mm_loaddup_pd (double const* mem_addr) /// - public static unsafe Vector128 LoadAndDuplicate(double* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAndDuplicate(double* address) => LoadAndDuplicate(address); /// /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) /// - public static unsafe Vector128 LoadDqu(sbyte* address) { throw new NotImplementedException(); } - public static unsafe Vector128 LoadDqu(byte* address) { throw new NotImplementedException(); } - public static unsafe Vector128 LoadDqu(short* address) { throw new NotImplementedException(); } - public static unsafe Vector128 LoadDqu(ushort* address) { throw new NotImplementedException(); } - public static unsafe Vector128 LoadDqu(int* address) { throw new NotImplementedException(); } - public static unsafe Vector128 LoadDqu(uint* address) { throw new NotImplementedException(); } - public static unsafe Vector128 LoadDqu(long* address) { throw new NotImplementedException(); } - public static unsafe Vector128 LoadDqu(ulong* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadDqu(sbyte* address) => LoadDqu(address); + public static unsafe Vector128 LoadDqu(byte* address) => LoadDqu(address); + public static unsafe Vector128 LoadDqu(short* address) => LoadDqu(address); + public static unsafe Vector128 LoadDqu(ushort* address) => LoadDqu(address); + public static unsafe Vector128 LoadDqu(int* address) => LoadDqu(address); + public static unsafe Vector128 LoadDqu(uint* address) => LoadDqu(address); + public static unsafe Vector128 LoadDqu(long* address) => LoadDqu(address); + public static unsafe Vector128 LoadDqu(ulong* address) => LoadDqu(address); /// /// __m128d _mm_movedup_pd (__m128d a) /// - public static Vector128 MoveAndDuplicate(Vector128 source) { throw new NotImplementedException(); } + public static Vector128 MoveAndDuplicate(Vector128 source) => MoveAndDuplicate(source); /// /// __m128 _mm_movehdup_ps (__m128 a) /// - public static Vector128 MoveHighAndDuplicate(Vector128 source) { throw new NotImplementedException(); } + public static Vector128 MoveHighAndDuplicate(Vector128 source) => MoveHighAndDuplicate(source); /// /// __m128 _mm_moveldup_ps (__m128 a) /// - public static Vector128 MoveLowAndDuplicate(Vector128 source) { throw new NotImplementedException(); } + public static Vector128 MoveLowAndDuplicate(Vector128 source) => MoveLowAndDuplicate(source); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs new file mode 100644 index 000000000000..4cc5a1ccbfe5 --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs @@ -0,0 +1,408 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel SSE4.1 hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Sse41 + { + public static bool IsSupported { get { return false; } } + + /// + /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8) + /// + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8) + /// + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// + public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// + public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m128 _mm_blendv_ps (__m128 a, __m128 b, __m128 mask) + /// + public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_blendv_pd (__m128d a, __m128d b, __m128d mask) + /// + public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_ceil_ps (__m128 a) + /// + public static Vector128 Ceiling(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_ceil_pd (__m128d a) + /// + public static Vector128 Ceiling(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) + /// + public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) + /// + public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cvtepi8_epi16 (__m128i a) + /// + public static Vector128 ConvertToShort(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepu8_epi16 (__m128i a) + /// + public static Vector128 ConvertToShort(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepi8_epi32 (__m128i a) + /// + public static Vector128 ConvertToInt(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepu8_epi32 (__m128i a) + /// + public static Vector128 ConvertToInt(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepi16_epi32 (__m128i a) + /// + public static Vector128 ConvertToInt(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepu16_epi32 (__m128i a) + /// + public static Vector128 ConvertToInt(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepi8_epi64 (__m128i a) + /// + public static Vector128 ConvertToLong(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepu8_epi64 (__m128i a) + /// + public static Vector128 ConvertToLong(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepi16_epi64 (__m128i a) + /// + public static Vector128 ConvertToLong(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepu16_epi64 (__m128i a) + /// + public static Vector128 ConvertToLong(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepi32_epi64 (__m128i a) + /// + public static Vector128 ConvertToLong(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_cvtepu32_epi64 (__m128i a) + /// + public static Vector128 ConvertToLong(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_extract_epi8 (__m128i a, const int imm8) + /// + public static sbyte ExtractSbyte(Vector128 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + /// + /// int _mm_extract_epi8 (__m128i a, const int imm8) + /// + public static byte ExtractByte(Vector128 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_extract_epi32 (__m128i a, const int imm8) + /// + public static int ExtractInt(Vector128 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_extract_epi32 (__m128i a, const int imm8) + /// + public static uint ExtractUint(Vector128 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) + /// + public static long ExtractLong(Vector128 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) + /// + public static ulong ExtractUlong(Vector128 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_extract_ps (__m128 a, const int imm8) + /// + public static float ExtractFloat(Vector128 value, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_floor_ps (__m128 a) + /// + public static Vector128 Floor(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128d _mm_floor_pd (__m128d a) + /// + public static Vector128 Floor(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) + /// + public static Vector128 InsertSbyte(Vector128 value, sbyte data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) + /// + public static Vector128 InsertByte(Vector128 value, byte data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) + /// + public static Vector128 InsertInt(Vector128 value, int data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) + /// + public static Vector128 InsertUint(Vector128 value, uint data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) + /// + public static Vector128 InsertLong(Vector128 value, long data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) + /// + public static Vector128 InsertUlong(Vector128 value, ulong data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8) + /// + public static Vector128 InsertFloat(Vector128 value, float data, byte index) where T : struct { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_max_epi8 (__m128i a, __m128i b) + /// + public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_max_epu16 (__m128i a, __m128i b) + /// + public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_max_epi32 (__m128i a, __m128i b) + /// + public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_max_epu32 (__m128i a, __m128i b) + /// + public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_min_epi8 (__m128i a, __m128i b) + /// + public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_min_epu16 (__m128i a, __m128i b) + /// + public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_min_epi32 (__m128i a, __m128i b) + /// + public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_min_epu32 (__m128i a, __m128i b) + /// + public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_minpos_epu16 (__m128i a) + /// + public static Vector128 MinHorizontal(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 MultipleSumAbsoluteDifferences(Vector128 left, Vector128 right, byte mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_mul_epi32 (__m128i a, __m128i b) + /// + public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b) + /// + public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_packus_epi32 (__m128i a, __m128i b) + /// + public static Vector128 PackUnsignedSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128 _mm_round_ps (__m128 a, int rounding) + /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC + /// + public static Vector128 RoundToNearestInteger(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC + /// + public static Vector128 RoundToNegativeInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC + /// + public static Vector128 RoundToPositiveInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC + /// + public static Vector128 RoundToZero(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_CUR_DIRECTION + /// + public static Vector128 RoundCurrentDirection(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128d _mm_round_pd (__m128d a, int rounding) + /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC + /// + public static Vector128 RoundToNearestInteger(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC + /// + public static Vector128 RoundToNegativeInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC + /// + public static Vector128 RoundToPositiveInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC + /// + public static Vector128 RoundToZero(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// _MM_FROUND_CUR_DIRECTION + /// + public static Vector128 RoundCurrentDirection(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// + public static unsafe Vector128 LoadAlignedNonTemporal(sbyte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// + public static unsafe Vector128 LoadAlignedNonTemporal(byte* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// + public static unsafe Vector128 LoadAlignedNonTemporal(short* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// + public static unsafe Vector128 LoadAlignedNonTemporal(ushort* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// + public static unsafe Vector128 LoadAlignedNonTemporal(int* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// + public static unsafe Vector128 LoadAlignedNonTemporal(uint* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// + public static unsafe Vector128 LoadAlignedNonTemporal(long* address) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// + public static unsafe Vector128 LoadAlignedNonTemporal(ulong* address) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_test_all_ones (__m128i a) + /// + public static bool TestAllOnes(Vector128 value) { throw new PlatformNotSupportedException(); } + public static bool TestAllOnes(Vector128 value) { throw new PlatformNotSupportedException(); } + public static bool TestAllOnes(Vector128 value) { throw new PlatformNotSupportedException(); } + public static bool TestAllOnes(Vector128 value) { throw new PlatformNotSupportedException(); } + public static bool TestAllOnes(Vector128 value) { throw new PlatformNotSupportedException(); } + public static bool TestAllOnes(Vector128 value) { throw new PlatformNotSupportedException(); } + public static bool TestAllOnes(Vector128 value) { throw new PlatformNotSupportedException(); } + public static bool TestAllOnes(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_test_all_zeros (__m128i a, __m128i mask) + /// + public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// + public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_test_mix_ones_zeros (__m128i a, __m128i mask) + /// + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// + public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.cs index 5a498bcf4efe..700347839810 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.cs @@ -13,396 +13,396 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Sse41 { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) /// - public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new NotImplementedException(); } + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) => Blend(left, right, control); /// /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) /// - public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new NotImplementedException(); } + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) => Blend(left, right, control); /// /// __m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8) /// - public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new NotImplementedException(); } + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) => Blend(left, right, control); /// /// __m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8) /// - public static Vector128 Blend(Vector128 left, Vector128 right, byte control) { throw new NotImplementedException(); } + public static Vector128 Blend(Vector128 left, Vector128 right, byte control) => Blend(left, right, control); /// /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) /// - public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new NotImplementedException(); } + public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) /// - public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new NotImplementedException(); } + public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// /// __m128 _mm_blendv_ps (__m128 a, __m128 b, __m128 mask) /// - public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new NotImplementedException(); } + public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// /// __m128d _mm_blendv_pd (__m128d a, __m128d b, __m128d mask) /// - public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new NotImplementedException(); } + public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// /// __m128 _mm_ceil_ps (__m128 a) /// - public static Vector128 Ceiling(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 Ceiling(Vector128 value) => Ceiling(value); /// /// __m128d _mm_ceil_pd (__m128d a) /// - public static Vector128 Ceiling(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 Ceiling(Vector128 value) => Ceiling(value); /// /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) /// - public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) /// - public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// /// __m128i _mm_cvtepi8_epi16 (__m128i a) /// - public static Vector128 ConvertToShort(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToShort(Vector128 value) => ConvertToShort(value); /// /// __m128i _mm_cvtepu8_epi16 (__m128i a) /// - public static Vector128 ConvertToShort(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToShort(Vector128 value) => ConvertToShort(value); /// /// __m128i _mm_cvtepi8_epi32 (__m128i a) /// - public static Vector128 ConvertToInt(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToInt(Vector128 value) => ConvertToInt(value); /// /// __m128i _mm_cvtepu8_epi32 (__m128i a) /// - public static Vector128 ConvertToInt(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToInt(Vector128 value) => ConvertToInt(value); /// /// __m128i _mm_cvtepi16_epi32 (__m128i a) /// - public static Vector128 ConvertToInt(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToInt(Vector128 value) => ConvertToInt(value); /// /// __m128i _mm_cvtepu16_epi32 (__m128i a) /// - public static Vector128 ConvertToInt(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToInt(Vector128 value) => ConvertToInt(value); /// /// __m128i _mm_cvtepi8_epi64 (__m128i a) /// - public static Vector128 ConvertToLong(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToLong(Vector128 value) => ConvertToLong(value); /// /// __m128i _mm_cvtepu8_epi64 (__m128i a) /// - public static Vector128 ConvertToLong(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToLong(Vector128 value) => ConvertToLong(value); /// /// __m128i _mm_cvtepi16_epi64 (__m128i a) /// - public static Vector128 ConvertToLong(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToLong(Vector128 value) => ConvertToLong(value); /// /// __m128i _mm_cvtepu16_epi64 (__m128i a) /// - public static Vector128 ConvertToLong(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToLong(Vector128 value) => ConvertToLong(value); /// /// __m128i _mm_cvtepi32_epi64 (__m128i a) /// - public static Vector128 ConvertToLong(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToLong(Vector128 value) => ConvertToLong(value); /// /// __m128i _mm_cvtepu32_epi64 (__m128i a) /// - public static Vector128 ConvertToLong(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 ConvertToLong(Vector128 value) => ConvertToLong(value); /// /// int _mm_extract_epi8 (__m128i a, const int imm8) /// - public static sbyte ExtractSbyte(Vector128 value, byte index) where T : struct { throw new NotImplementedException(); } + public static sbyte ExtractSbyte(Vector128 value, byte index) where T : struct => ExtractSbyte(value, index); /// /// int _mm_extract_epi8 (__m128i a, const int imm8) /// - public static byte ExtractByte(Vector128 value, byte index) where T : struct { throw new NotImplementedException(); } + public static byte ExtractByte(Vector128 value, byte index) where T : struct => ExtractByte(value, index); /// /// int _mm_extract_epi32 (__m128i a, const int imm8) /// - public static int ExtractInt(Vector128 value, byte index) where T : struct { throw new NotImplementedException(); } + public static int ExtractInt(Vector128 value, byte index) where T : struct => ExtractInt(value, index); /// /// int _mm_extract_epi32 (__m128i a, const int imm8) /// - public static uint ExtractUint(Vector128 value, byte index) where T : struct { throw new NotImplementedException(); } + public static uint ExtractUint(Vector128 value, byte index) where T : struct => ExtractUint(value, index); /// /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) /// - public static long ExtractLong(Vector128 value, byte index) where T : struct { throw new NotImplementedException(); } + public static long ExtractLong(Vector128 value, byte index) where T : struct => ExtractLong(value, index); /// /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) /// - public static ulong ExtractUlong(Vector128 value, byte index) where T : struct { throw new NotImplementedException(); } + public static ulong ExtractUlong(Vector128 value, byte index) where T : struct => ExtractUlong(value, index); /// /// int _mm_extract_ps (__m128 a, const int imm8) /// - public static float ExtractFloat(Vector128 value, byte index) where T : struct { throw new NotImplementedException(); } + public static float ExtractFloat(Vector128 value, byte index) where T : struct => ExtractFloat(value, index); /// /// __m128 _mm_floor_ps (__m128 a) /// - public static Vector128 Floor(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 Floor(Vector128 value) => Floor(value); /// /// __m128d _mm_floor_pd (__m128d a) /// - public static Vector128 Floor(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 Floor(Vector128 value) => Floor(value); /// /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) /// - public static Vector128 InsertSbyte(Vector128 value, sbyte data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector128 InsertSbyte(Vector128 value, sbyte data, byte index) where T : struct => InsertSbyte(value, data, index); /// /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) /// - public static Vector128 InsertByte(Vector128 value, byte data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector128 InsertByte(Vector128 value, byte data, byte index) where T : struct => InsertByte(value, data, index); /// /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) /// - public static Vector128 InsertInt(Vector128 value, int data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector128 InsertInt(Vector128 value, int data, byte index) where T : struct => InsertInt(value, data, index); /// /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) /// - public static Vector128 InsertUint(Vector128 value, uint data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector128 InsertUint(Vector128 value, uint data, byte index) where T : struct => InsertUint(value, data, index); /// /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) /// - public static Vector128 InsertLong(Vector128 value, long data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector128 InsertLong(Vector128 value, long data, byte index) where T : struct => InsertLong(value, data, index); /// /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) /// - public static Vector128 InsertUlong(Vector128 value, ulong data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector128 InsertUlong(Vector128 value, ulong data, byte index) where T : struct => InsertUlong(value, data, index); /// /// __m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8) /// - public static Vector128 InsertFloat(Vector128 value, float data, byte index) where T : struct { throw new NotImplementedException(); } + public static Vector128 InsertFloat(Vector128 value, float data, byte index) where T : struct => InsertFloat(value, data, index); /// /// __m128i _mm_max_epi8 (__m128i a, __m128i b) /// - public static Vector128 Max(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// /// __m128i _mm_max_epu16 (__m128i a, __m128i b) /// - public static Vector128 Max(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// /// __m128i _mm_max_epi32 (__m128i a, __m128i b) /// - public static Vector128 Max(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// /// __m128i _mm_max_epu32 (__m128i a, __m128i b) /// - public static Vector128 Max(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// /// __m128i _mm_min_epi8 (__m128i a, __m128i b) /// - public static Vector128 Min(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// /// __m128i _mm_min_epu16 (__m128i a, __m128i b) /// - public static Vector128 Min(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// /// __m128i _mm_min_epi32 (__m128i a, __m128i b) /// - public static Vector128 Min(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// /// __m128i _mm_min_epu32 (__m128i a, __m128i b) /// - public static Vector128 Min(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// /// __m128i _mm_minpos_epu16 (__m128i a) /// - public static Vector128 MinHorizontal(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 MinHorizontal(Vector128 value) => MinHorizontal(value); /// /// __m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8) /// - public static Vector128 MultipleSumAbsoluteDifferences(Vector128 left, Vector128 right, byte mask) { throw new NotImplementedException(); } + public static Vector128 MultipleSumAbsoluteDifferences(Vector128 left, Vector128 right, byte mask) => MultipleSumAbsoluteDifferences(left, right, mask); /// /// __m128i _mm_mul_epi32 (__m128i a, __m128i b) /// - public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b) /// - public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 MultiplyLow(Vector128 left, Vector128 right) => MultiplyLow(left, right); /// /// __m128i _mm_packus_epi32 (__m128i a, __m128i b) /// - public static Vector128 PackUnsignedSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 PackUnsignedSaturate(Vector128 left, Vector128 right) => PackUnsignedSaturate(left, right); /// /// __m128 _mm_round_ps (__m128 a, int rounding) /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC /// - public static Vector128 RoundToNearestInteger(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 RoundToNearestInteger(Vector128 value) => RoundToNearestInteger(value); /// /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC /// - public static Vector128 RoundToNegativeInfinity(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 RoundToNegativeInfinity(Vector128 value) => RoundToNegativeInfinity(value); /// /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC /// - public static Vector128 RoundToPositiveInfinity(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 RoundToPositiveInfinity(Vector128 value) => RoundToPositiveInfinity(value); /// /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC /// - public static Vector128 RoundToZero(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 RoundToZero(Vector128 value) => RoundToZero(value); /// /// _MM_FROUND_CUR_DIRECTION /// - public static Vector128 RoundCurrentDirection(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 RoundCurrentDirection(Vector128 value) => RoundCurrentDirection(value); /// /// __m128d _mm_round_pd (__m128d a, int rounding) /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC /// - public static Vector128 RoundToNearestInteger(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 RoundToNearestInteger(Vector128 value) => RoundToNearestInteger(value); /// /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC /// - public static Vector128 RoundToNegativeInfinity(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 RoundToNegativeInfinity(Vector128 value) => RoundToNegativeInfinity(value); /// /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC /// - public static Vector128 RoundToPositiveInfinity(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 RoundToPositiveInfinity(Vector128 value) => RoundToPositiveInfinity(value); /// /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC /// - public static Vector128 RoundToZero(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 RoundToZero(Vector128 value) => RoundToZero(value); /// /// _MM_FROUND_CUR_DIRECTION /// - public static Vector128 RoundCurrentDirection(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 RoundCurrentDirection(Vector128 value) => RoundCurrentDirection(value); /// /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) /// - public static unsafe Vector128 LoadAlignedNonTemporal(sbyte* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAlignedNonTemporal(sbyte* address) => LoadAlignedNonTemporal(address); /// /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) /// - public static unsafe Vector128 LoadAlignedNonTemporal(byte* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAlignedNonTemporal(byte* address) => LoadAlignedNonTemporal(address); /// /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) /// - public static unsafe Vector128 LoadAlignedNonTemporal(short* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAlignedNonTemporal(short* address) => LoadAlignedNonTemporal(address); /// /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) /// - public static unsafe Vector128 LoadAlignedNonTemporal(ushort* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAlignedNonTemporal(ushort* address) => LoadAlignedNonTemporal(address); /// /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) /// - public static unsafe Vector128 LoadAlignedNonTemporal(int* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAlignedNonTemporal(int* address) => LoadAlignedNonTemporal(address); /// /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) /// - public static unsafe Vector128 LoadAlignedNonTemporal(uint* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAlignedNonTemporal(uint* address) => LoadAlignedNonTemporal(address); /// /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) /// - public static unsafe Vector128 LoadAlignedNonTemporal(long* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAlignedNonTemporal(long* address) => LoadAlignedNonTemporal(address); /// /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) /// - public static unsafe Vector128 LoadAlignedNonTemporal(ulong* address) { throw new NotImplementedException(); } + public static unsafe Vector128 LoadAlignedNonTemporal(ulong* address) => LoadAlignedNonTemporal(address); /// /// int _mm_test_all_ones (__m128i a) /// - public static bool TestAllOnes(Vector128 value) { throw new NotImplementedException(); } - public static bool TestAllOnes(Vector128 value) { throw new NotImplementedException(); } - public static bool TestAllOnes(Vector128 value) { throw new NotImplementedException(); } - public static bool TestAllOnes(Vector128 value) { throw new NotImplementedException(); } - public static bool TestAllOnes(Vector128 value) { throw new NotImplementedException(); } - public static bool TestAllOnes(Vector128 value) { throw new NotImplementedException(); } - public static bool TestAllOnes(Vector128 value) { throw new NotImplementedException(); } - public static bool TestAllOnes(Vector128 value) { throw new NotImplementedException(); } + public static bool TestAllOnes(Vector128 value) => TestAllOnes(value); + public static bool TestAllOnes(Vector128 value) => TestAllOnes(value); + public static bool TestAllOnes(Vector128 value) => TestAllOnes(value); + public static bool TestAllOnes(Vector128 value) => TestAllOnes(value); + public static bool TestAllOnes(Vector128 value) => TestAllOnes(value); + public static bool TestAllOnes(Vector128 value) => TestAllOnes(value); + public static bool TestAllOnes(Vector128 value) => TestAllOnes(value); + public static bool TestAllOnes(Vector128 value) => TestAllOnes(value); /// /// int _mm_test_all_zeros (__m128i a, __m128i mask) /// - public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestAllZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestAllZeros(Vector128 left, Vector128 right) => TestAllZeros(left, right); + public static bool TestAllZeros(Vector128 left, Vector128 right) => TestAllZeros(left, right); + public static bool TestAllZeros(Vector128 left, Vector128 right) => TestAllZeros(left, right); + public static bool TestAllZeros(Vector128 left, Vector128 right) => TestAllZeros(left, right); + public static bool TestAllZeros(Vector128 left, Vector128 right) => TestAllZeros(left, right); + public static bool TestAllZeros(Vector128 left, Vector128 right) => TestAllZeros(left, right); + public static bool TestAllZeros(Vector128 left, Vector128 right) => TestAllZeros(left, right); + public static bool TestAllZeros(Vector128 left, Vector128 right) => TestAllZeros(left, right); /// /// int _mm_testc_si128 (__m128i a, __m128i b) /// - public static bool TestC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); + public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); + public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); + public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); + public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); + public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); + public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); + public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// /// int _mm_test_mix_ones_zeros (__m128i a, __m128i mask) /// - public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestMixOnesZeros(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) => TestMixOnesZeros(left, right); + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) => TestMixOnesZeros(left, right); + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) => TestMixOnesZeros(left, right); + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) => TestMixOnesZeros(left, right); + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) => TestMixOnesZeros(left, right); + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) => TestMixOnesZeros(left, right); + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) => TestMixOnesZeros(left, right); + public static bool TestMixOnesZeros(Vector128 left, Vector128 right) => TestMixOnesZeros(left, right); /// /// int _mm_testnzc_si128 (__m128i a, __m128i b) /// - public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); + public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// /// int _mm_testz_si128 (__m128i a, __m128i b) /// - public static bool TestZ(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestZ(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestZ(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestZ(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestZ(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestZ(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestZ(Vector128 left, Vector128 right) { throw new NotImplementedException(); } - public static bool TestZ(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); + public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); + public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); + public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); + public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); + public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); + public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); + public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse42.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse42.PlatformNotSupported.cs new file mode 100644 index 000000000000..3db94c1afb94 --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse42.PlatformNotSupported.cs @@ -0,0 +1,233 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel SSE4.2 hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Sse42 + { + public static bool IsSupported { get { return false; } } + + /// + /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrc (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistro (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8) + /// + public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrc (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistro (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8) + /// + public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrc (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistro (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8) + /// + public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + + /// + /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrc (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistro (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8) + /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8) + /// + public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrc (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestro (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrc (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestro (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrc (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestro (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrc (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestro (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8) + /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8) + /// + public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8) + /// + public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8) + /// + public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8) + /// + public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) + /// + public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) + /// + public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_cmpgt_epi64 (__m128i a, __m128i b) + /// + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// unsigned int _mm_crc32_u8 (unsigned int crc, unsigned char v) + /// + public static uint Crc32(uint crc, byte data) { throw new PlatformNotSupportedException(); } + /// + /// unsigned int _mm_crc32_u16 (unsigned int crc, unsigned short v) + /// + public static uint Crc32(uint crc, ushort data) { throw new PlatformNotSupportedException(); } + /// + /// unsigned int _mm_crc32_u32 (unsigned int crc, unsigned int v) + /// + public static uint Crc32(uint crc, uint data) { throw new PlatformNotSupportedException(); } + /// + /// unsigned __int64 _mm_crc32_u64 (unsigned __int64 crc, unsigned __int64 v) + /// + public static ulong Crc32(ulong crc, ulong data) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse42.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse42.cs index f644577ae170..f98867cb9d0a 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse42.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse42.cs @@ -13,7 +13,7 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Sse42 { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8) @@ -22,7 +22,7 @@ public static class Sse42 /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8) /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8) /// - public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); } + public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) => CompareImplicitLength(left, right, flag, mode); /// /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8) @@ -31,7 +31,7 @@ public static class Sse42 /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8) /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8) /// - public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); } + public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) => CompareImplicitLength(left, right, flag, mode); /// /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8) @@ -40,7 +40,7 @@ public static class Sse42 /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8) /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8) /// - public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); } + public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) => CompareImplicitLength(left, right, flag, mode); /// @@ -50,7 +50,7 @@ public static class Sse42 /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8) /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8) /// - public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); } + public static bool CompareImplicitLength(Vector128 left, Vector128 right, ResultsFlag flag, StringComparisonMode mode) => CompareImplicitLength(left, right, flag, mode); /// /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8) @@ -59,7 +59,7 @@ public static class Sse42 /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8) /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); } + public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) => CompareExplicitLength(left, leftLength, right, rightLength, flag, mode); /// /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8) @@ -68,7 +68,7 @@ public static class Sse42 /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8) /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); } + public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) => CompareExplicitLength(left, leftLength, right, rightLength, flag, mode); /// /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8) @@ -77,7 +77,7 @@ public static class Sse42 /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8) /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); } + public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) => CompareExplicitLength(left, leftLength, right, rightLength, flag, mode); /// /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8) @@ -86,148 +86,148 @@ public static class Sse42 /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8) /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); } + public static bool CompareExplicitLength(Vector128 left, byte leftLength, Vector128 right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) => CompareExplicitLength(left, leftLength, right, rightLength, flag, mode); /// /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8) /// - public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthIndex(left, right, mode); /// /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8) /// - public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthIndex(left, right, mode); /// /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8) /// - public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthIndex(left, right, mode); /// /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8) /// - public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static int CompareImplicitLengthIndex(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthIndex(left, right, mode); /// /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthIndex(left, leftLength, right, rightLength, mode); /// /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthIndex(left, leftLength, right, rightLength, mode); /// /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthIndex(left, leftLength, right, rightLength, mode); /// /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static int CompareExplicitLengthIndex(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthIndex(left, leftLength, right, rightLength, mode); /// /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) /// - public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthBitMask(left, right, mode); /// /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) /// - public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthBitMask(left, right, mode); /// /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) /// - public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthBitMask(left, right, mode); /// /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) /// - public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareImplicitLengthBitMask(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthBitMask(left, right, mode); /// /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) /// - public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthUnitMask(left, right, mode); /// /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) /// - public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthUnitMask(left, right, mode); /// /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) /// - public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthUnitMask(left, right, mode); /// /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8) /// - public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareImplicitLengthUnitMask(Vector128 left, Vector128 right, StringComparisonMode mode) => CompareImplicitLengthUnitMask(left, right, mode); /// /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthBitMask(left, leftLength, right, rightLength, mode); /// /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthBitMask(left, leftLength, right, rightLength, mode); /// /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthBitMask(left, leftLength, right, rightLength, mode); /// /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareExplicitLengthBitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthBitMask(left, leftLength, right, rightLength, mode); /// /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthUnitMask(left, leftLength, right, rightLength, mode); /// /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthUnitMask(left, leftLength, right, rightLength, mode); /// /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthUnitMask(left, leftLength, right, rightLength, mode); /// /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8) /// - public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); } + public static Vector128 CompareExplicitLengthUnitMask(Vector128 left, byte leftLength, Vector128 right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthUnitMask(left, leftLength, right, rightLength, mode); /// /// __m128i _mm_cmpgt_epi64 (__m128i a, __m128i b) /// - public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// /// unsigned int _mm_crc32_u8 (unsigned int crc, unsigned char v) /// - public static uint Crc32(uint crc, byte data) { throw new NotImplementedException(); } + public static uint Crc32(uint crc, byte data) => Crc32(crc, data); /// /// unsigned int _mm_crc32_u16 (unsigned int crc, unsigned short v) /// - public static uint Crc32(uint crc, ushort data) { throw new NotImplementedException(); } + public static uint Crc32(uint crc, ushort data) => Crc32(crc, data); /// /// unsigned int _mm_crc32_u32 (unsigned int crc, unsigned int v) /// - public static uint Crc32(uint crc, uint data) { throw new NotImplementedException(); } + public static uint Crc32(uint crc, uint data) => Crc32(crc, data); /// /// unsigned __int64 _mm_crc32_u64 (unsigned __int64 crc, unsigned __int64 v) /// - public static ulong Crc32(ulong crc, ulong data) { throw new NotImplementedException(); } + public static ulong Crc32(ulong crc, ulong data) => Crc32(crc, data); } } diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs new file mode 100644 index 000000000000..1bc8e232fd3a --- /dev/null +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs @@ -0,0 +1,92 @@ +// 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; +using System.Runtime.Intrinsics; + +namespace System.Runtime.Intrinsics.X86 +{ + /// + /// This class provides access to Intel SSSE3 hardware instructions via intrinsics + /// + [CLSCompliant(false)] + public static class Ssse3 + { + public static bool IsSupported { get { return false; } } + + /// + /// __m128i _mm_abs_epi8 (__m128i a) + /// + public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_abs_epi16 (__m128i a) + /// + public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_abs_epi32 (__m128i a) + /// + public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// + public static Vector128 AlignRight(Vector128 left, Vector128 right, byte mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_hadd_epi16 (__m128i a, __m128i b) + /// + public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_hadd_epi32 (__m128i a, __m128i b) + /// + public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_hadds_epi16 (__m128i a, __m128i b) + /// + public static Vector128 HorizontalAddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_hsub_epi16 (__m128i a, __m128i b) + /// + public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_hsub_epi32 (__m128i a, __m128i b) + /// + public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_hsubs_epi16 (__m128i a, __m128i b) + /// + public static Vector128 HorizontalSubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_maddubs_epi16 (__m128i a, __m128i b) + /// + public static Vector128 MultiplyAddAdjacent(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_mulhrs_epi16 (__m128i a, __m128i b) + /// + public static Vector128 MultiplyHighRoundScale(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b) + /// + public static Vector128 Shuffle(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } + + /// + /// __m128i _mm_sign_epi8 (__m128i a, __m128i b) + /// + public static Vector128 Sign(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_sign_epi16 (__m128i a, __m128i b) + /// + public static Vector128 Sign(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + /// + /// __m128i _mm_sign_epi32 (__m128i a, __m128i b) + /// + public static Vector128 Sign(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } + } +} diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Ssse3.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Ssse3.cs index 0ce9036a8f03..d336d2eef9bb 100644 --- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Ssse3.cs +++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Ssse3.cs @@ -13,80 +13,80 @@ namespace System.Runtime.Intrinsics.X86 [CLSCompliant(false)] public static class Ssse3 { - public static bool IsSupported { get { return false; } } + public static bool IsSupported { get => IsSupported; } /// /// __m128i _mm_abs_epi8 (__m128i a) /// - public static Vector128 Abs(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 Abs(Vector128 value) => Abs(value); /// /// __m128i _mm_abs_epi16 (__m128i a) /// - public static Vector128 Abs(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 Abs(Vector128 value) => Abs(value); /// /// __m128i _mm_abs_epi32 (__m128i a) /// - public static Vector128 Abs(Vector128 value) { throw new NotImplementedException(); } + public static Vector128 Abs(Vector128 value) => Abs(value); /// /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) /// - public static Vector128 AlignRight(Vector128 left, Vector128 right, byte mask) { throw new NotImplementedException(); } + public static Vector128 AlignRight(Vector128 left, Vector128 right, byte mask) => AlignRight(left, right, mask); /// /// __m128i _mm_hadd_epi16 (__m128i a, __m128i b) /// - public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) => HorizontalAdd(left, right); /// /// __m128i _mm_hadd_epi32 (__m128i a, __m128i b) /// - public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) => HorizontalAdd(left, right); /// /// __m128i _mm_hadds_epi16 (__m128i a, __m128i b) /// - public static Vector128 HorizontalAddSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 HorizontalAddSaturate(Vector128 left, Vector128 right) => HorizontalAddSaturate(left, right); /// /// __m128i _mm_hsub_epi16 (__m128i a, __m128i b) /// - public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) => HorizontalSubtract(left, right); /// /// __m128i _mm_hsub_epi32 (__m128i a, __m128i b) /// - public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) => HorizontalSubtract(left, right); /// /// __m128i _mm_hsubs_epi16 (__m128i a, __m128i b) /// - public static Vector128 HorizontalSubtractSaturate(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 HorizontalSubtractSaturate(Vector128 left, Vector128 right) => HorizontalSubtractSaturate(left, right); /// /// __m128i _mm_maddubs_epi16 (__m128i a, __m128i b) /// - public static Vector128 MultiplyAddAdjacent(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 MultiplyAddAdjacent(Vector128 left, Vector128 right) => MultiplyAddAdjacent(left, right); /// /// __m128i _mm_mulhrs_epi16 (__m128i a, __m128i b) /// - public static Vector128 MultiplyHighRoundScale(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 MultiplyHighRoundScale(Vector128 left, Vector128 right) => MultiplyHighRoundScale(left, right); /// /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b) /// - public static Vector128 Shuffle(Vector128 value, Vector128 mask) { throw new NotImplementedException(); } + public static Vector128 Shuffle(Vector128 value, Vector128 mask) => Shuffle(value, mask); /// /// __m128i _mm_sign_epi8 (__m128i a, __m128i b) /// - public static Vector128 Sign(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Sign(Vector128 left, Vector128 right) => Sign(left, right); /// /// __m128i _mm_sign_epi16 (__m128i a, __m128i b) /// - public static Vector128 Sign(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Sign(Vector128 left, Vector128 right) => Sign(left, right); /// /// __m128i _mm_sign_epi32 (__m128i a, __m128i b) /// - public static Vector128 Sign(Vector128 left, Vector128 right) { throw new NotImplementedException(); } + public static Vector128 Sign(Vector128 left, Vector128 right) => Sign(left, right); } }