Explode generic Intel hardware intrinsic on all the supported types

4 files changed, 847 insertions, 91 deletions

diff --git a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs
index d6597cfb56..0eb6ffeec1 100644
--- a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs
+++ b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs
@@ -268,14 +268,64 @@ namespace System.Runtime.Intrinsics.X86
         public static ulong Extract(Vector256<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8)
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
-        /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8)
+        /// </summary>
+        public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<short> ExtractVector128(Vector256<short> value, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<int> ExtractVector128(Vector256<int> value, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<long> ExtractVector128(Vector256<long> value, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<T> ExtractVector128<T>(Vector256<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<float> ExtractVector128(Vector256<float> value, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<double> ExtractVector128(Vector256<double> value, byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
@@ -423,14 +473,64 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector256<ulong> Insert(Vector256<ulong> value, ulong data, byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
-        /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
+        /// </summary>
+        public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<T> InsertVector128<T>(Vector256<T> value, Vector128<T> data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<float> InsertVector128(Vector256<float> value, Vector128<float> data, byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<double> InsertVector128(Vector256<double> value, Vector128<double> data, byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
@@ -748,14 +848,63 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector256<double> Permute(Vector256<double> value, byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8)
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
-        /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8)
+        /// </summary>
+        public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) { throw new PlatformNotSupportedException(); }
+        
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<T> Permute2x128<T>(Vector256<T> left, Vector256<T> right, byte control) where T : struct { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, byte control) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128 _mm_permutevar_ps (__m128 a, __m128i b)
@@ -1145,12 +1294,62 @@ namespace System.Runtime.Intrinsics.X86
         /// <summary>
         /// int _mm256_testc_si256 (__m256i a, __m256i b)
         ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// int _mm256_testc_ps (__m256 a, __m256 b)
         ///   VTESTPS ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// int _mm256_testc_pd (__m256d a, __m256d b)
         ///   VTESTPS ymm, ymm/m256
         /// </summary>
-        public static bool TestC<T>(Vector256<T> left, Vector256<T> right) where T : struct { throw new PlatformNotSupportedException(); }
+        public static bool TestC(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int _mm_testnzc_ps (__m128 a, __m128 b)
@@ -1166,12 +1365,62 @@ namespace System.Runtime.Intrinsics.X86
         /// <summary>
         /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
         ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// int _mm256_testnzc_ps (__m256 a, __m256 b)
         ///   VTESTPS ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// int _mm256_testnzc_pd (__m256d a, __m256d b)
         ///   VTESTPD ymm, ymm/m256
         /// </summary>
-        public static bool TestNotZAndNotC<T>(Vector256<T> left, Vector256<T> right) where T : struct { throw new PlatformNotSupportedException(); }
+        public static bool TestNotZAndNotC(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int _mm_testz_ps (__m128 a, __m128 b)
@@ -1187,12 +1436,62 @@ namespace System.Runtime.Intrinsics.X86
         /// <summary>
         /// int _mm256_testz_si256 (__m256i a, __m256i b)
         ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// int _mm256_testz_ps (__m256 a, __m256 b)
         ///   VTESTPS ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// int _mm256_testz_pd (__m256d a, __m256d b)
         ///   VTESTPD ymm, ymm/m256
         /// </summary>
-        public static bool TestZ<T>(Vector256<T> left, Vector256<T> right) where T : struct { throw new PlatformNotSupportedException(); }
+        public static bool TestZ(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256 _mm256_unpackhi_ps (__m256 a, __m256 b)
diff --git a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx.cs b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx.cs
index 3cb6849a6b..ec83865b10 100644
--- a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx.cs
+++ b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx.cs
@@ -317,17 +317,64 @@ namespace System.Runtime.Intrinsics.X86
         }
 
         /// <summary>
-        /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8)
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
-        /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8)
+        /// </summary>
+        public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) => ExtractVector128(value, index);
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) => ExtractVector128(value, index);
+
+        /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<T> ExtractVector128<T>(Vector256<T> value, byte index) where T : struct
-        {
-            return ExtractVector128<T>(value, index);
-        }
+        public static Vector128<short> ExtractVector128(Vector256<short> value, byte index) => ExtractVector128(value, index);
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) => ExtractVector128(value, index);
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<int> ExtractVector128(Vector256<int> value, byte index) => ExtractVector128(value, index);
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) => ExtractVector128(value, index);
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<long> ExtractVector128(Vector256<long> value, byte index) => ExtractVector128(value, index);
+
+        /// <summary>
+        /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) => ExtractVector128(value, index);
+
+        /// <summary>
+        /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<float> ExtractVector128(Vector256<float> value, byte index) => ExtractVector128(value, index);
+
+        /// <summary>
+        /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8)
+        ///   VEXTRACTF128 xmm/m128, ymm, imm8
+        /// </summary>
+        public static Vector128<double> ExtractVector128(Vector256<double> value, byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
@@ -578,17 +625,64 @@ namespace System.Runtime.Intrinsics.X86
         }
 
         /// <summary>
-        /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
-        /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
+        /// </summary>
+        public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index) => InsertVector128(value, data, index);
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index) => InsertVector128(value, data, index);
+
+        /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<T> InsertVector128<T>(Vector256<T> value, Vector128<T> data, byte index) where T : struct
-        {
-            return InsertVector128<T>(value, data, index);
-        }
+        public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index) => InsertVector128(value, data, index);
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index) => InsertVector128(value, data, index);
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index) => InsertVector128(value, data, index);
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index) => InsertVector128(value, data, index);
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index) => InsertVector128(value, data, index);
+
+        /// <summary>
+        /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index) => InsertVector128(value, data, index);
+
+        /// <summary>
+        /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<float> InsertVector128(Vector256<float> value, Vector128<float> data, byte index) => InsertVector128(value, data, index);
+
+        /// <summary>
+        /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
+        ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
+        /// </summary>
+        public static Vector256<double> InsertVector128(Vector256<double> value, Vector128<double> data, byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
@@ -906,17 +1000,63 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector256<double> Permute(Vector256<double> value, byte control) => Permute(value, control);
 
         /// <summary>
-        /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8)
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
-        /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8)
+        /// </summary>
+        public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) => Permute2x128(left, right, control);
+
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) => Permute2x128(left, right, control);
+
+        /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<T> Permute2x128<T>(Vector256<T> left, Vector256<T> right, byte control) where T : struct
-        {
-            return Permute2x128<T>(left, right, control);
-        }
+        public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) => Permute2x128(left, right, control);
+        
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) => Permute2x128(left, right, control);
+
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) => Permute2x128(left, right, control);
+
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) => Permute2x128(left, right, control);
+
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) => Permute2x128(left, right, control);
+
+        /// <summary>
+        /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) => Permute2x128(left, right, control);
+        /// <summary>
+        /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, byte control) => Permute2x128(left, right, control);
+
+        /// <summary>
+        /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8)
+        ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
+        /// </summary>
+        public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m128 _mm_permutevar_ps (__m128 a, __m128i b)
@@ -1318,15 +1458,62 @@ namespace System.Runtime.Intrinsics.X86
         /// <summary>
         /// int _mm256_testc_si256 (__m256i a, __m256i b)
         ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<byte> left, Vector256<byte> right) => TestC(left, right);
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<sbyte> left, Vector256<sbyte> right) => TestC(left, right);
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<short> left, Vector256<short> right) => TestC(left, right);
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<ushort> left, Vector256<ushort> right) => TestC(left, right);
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<int> left, Vector256<int> right) => TestC(left, right);
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<uint> left, Vector256<uint> right) => TestC(left, right);
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<long> left, Vector256<long> right) => TestC(left, right);
+
+        /// <summary>
+        /// int _mm256_testc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<ulong> left, Vector256<ulong> right) => TestC(left, right);
+
+        /// <summary>
         /// int _mm256_testc_ps (__m256 a, __m256 b)
         ///   VTESTPS ymm, ymm/m256
+        /// </summary>
+        public static bool TestC(Vector256<float> left, Vector256<float> right) => TestC(left, right);
+
+        /// <summary>
         /// int _mm256_testc_pd (__m256d a, __m256d b)
         ///   VTESTPS ymm, ymm/m256
         /// </summary>
-        public static bool TestC<T>(Vector256<T> left, Vector256<T> right) where T : struct
-        {
-            return TestC<T>(left, right);
-        }
+        public static bool TestC(Vector256<double> left, Vector256<double> right) => TestC(left, right);
 
         /// <summary>
         /// int _mm_testnzc_ps (__m128 a, __m128 b)
@@ -1342,15 +1529,62 @@ namespace System.Runtime.Intrinsics.X86
         /// <summary>
         /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
         ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<byte> left, Vector256<byte> right) => TestNotZAndNotC(left, right);
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<sbyte> left, Vector256<sbyte> right) => TestNotZAndNotC(left, right);
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<short> left, Vector256<short> right) => TestNotZAndNotC(left, right);
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<ushort> left, Vector256<ushort> right) => TestNotZAndNotC(left, right);
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<int> left, Vector256<int> right) => TestNotZAndNotC(left, right);
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<uint> left, Vector256<uint> right) => TestNotZAndNotC(left, right);
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<long> left, Vector256<long> right) => TestNotZAndNotC(left, right);
+
+        /// <summary>
+        /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<ulong> left, Vector256<ulong> right) => TestNotZAndNotC(left, right);
+
+        /// <summary>
         /// int _mm256_testnzc_ps (__m256 a, __m256 b)
         ///   VTESTPS ymm, ymm/m256
+        /// </summary>
+        public static bool TestNotZAndNotC(Vector256<float> left, Vector256<float> right) => TestNotZAndNotC(left, right);
+
+        /// <summary>
         /// int _mm256_testnzc_pd (__m256d a, __m256d b)
         ///   VTESTPD ymm, ymm/m256
         /// </summary>
-        public static bool TestNotZAndNotC<T>(Vector256<T> left, Vector256<T> right) where T : struct
-        {
-            return TestNotZAndNotC<T>(left, right);
-        }
+        public static bool TestNotZAndNotC(Vector256<double> left, Vector256<double> right) => TestNotZAndNotC(left, right);
 
         /// <summary>
         /// int _mm_testz_ps (__m128 a, __m128 b)
@@ -1366,15 +1600,62 @@ namespace System.Runtime.Intrinsics.X86
         /// <summary>
         /// int _mm256_testz_si256 (__m256i a, __m256i b)
         ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<byte> left, Vector256<byte> right) => TestZ(left, right);
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<sbyte> left, Vector256<sbyte> right) => TestZ(left, right);
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<short> left, Vector256<short> right) => TestZ(left, right);
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<ushort> left, Vector256<ushort> right) => TestZ(left, right);
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<int> left, Vector256<int> right) => TestZ(left, right);
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<uint> left, Vector256<uint> right) => TestZ(left, right);
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<long> left, Vector256<long> right) => TestZ(left, right);
+
+        /// <summary>
+        /// int _mm256_testz_si256 (__m256i a, __m256i b)
+        ///   VPTEST ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<ulong> left, Vector256<ulong> right) => TestZ(left, right);
+
+        /// <summary>
         /// int _mm256_testz_ps (__m256 a, __m256 b)
         ///   VTESTPS ymm, ymm/m256
+        /// </summary>
+        public static bool TestZ(Vector256<float> left, Vector256<float> right) => TestZ(left, right);
+
+        /// <summary>
         /// int _mm256_testz_pd (__m256d a, __m256d b)
         ///   VTESTPD ymm, ymm/m256
         /// </summary>
-        public static bool TestZ<T>(Vector256<T> left, Vector256<T> right) where T : struct
-        {
-            return TestZ<T>(left, right);
-        }
+        public static bool TestZ(Vector256<double> left, Vector256<double> right) => TestZ(left, right);
 
         /// <summary>
         /// __m256 _mm256_unpackhi_ps (__m256 a, __m256 b)
diff --git a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
index acb5c66261..a2dd4edbc7 100644
--- a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
+++ b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
@@ -326,18 +326,62 @@ namespace System.Runtime.Intrinsics.X86
         /// <summary>
         /// __m128i _mm_broadcastb_epi8 (__m128i a)
         ///   VPBROADCASTB xmm, xmm
+        /// </summary>
+        public static Vector128<byte> BroadcastScalarToVector128(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128i _mm_broadcastb_epi8 (__m128i a)
+        ///   VPBROADCASTB xmm, xmm
+        /// </summary>
+        public static Vector128<sbyte> BroadcastScalarToVector128(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128i _mm_broadcastw_epi16 (__m128i a)
+        ///   VPBROADCASTW xmm, xmm
+        /// </summary>
+        public static Vector128<short> BroadcastScalarToVector128(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_broadcastw_epi16 (__m128i a)
         ///   VPBROADCASTW xmm, xmm
+        /// </summary>
+        public static Vector128<ushort> BroadcastScalarToVector128(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_broadcastd_epi32 (__m128i a)
         ///   VPBROADCASTD xmm, xmm
+        /// </summary>
+        public static Vector128<int> BroadcastScalarToVector128(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128i _mm_broadcastd_epi32 (__m128i a)
+        ///   VPBROADCASTD xmm, xmm
+        /// </summary>
+        public static Vector128<uint> BroadcastScalarToVector128(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_broadcastq_epi64 (__m128i a)
         ///   VPBROADCASTQ xmm, xmm
+        /// </summary>
+        public static Vector128<long> BroadcastScalarToVector128(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128i _mm_broadcastq_epi64 (__m128i a)
+        ///   VPBROADCASTQ xmm, xmm
+        /// </summary>
+        public static Vector128<ulong> BroadcastScalarToVector128(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_broadcastss_ps (__m128 a)
         ///   VBROADCASTSS xmm, xmm
+        /// </summary>
+        public static Vector128<float> BroadcastScalarToVector128(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_broadcastsd_pd (__m128d a)
         ///   VMOVDDUP xmm, xmm
         /// </summary>
-        public static Vector128<T> BroadcastScalarToVector128<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> BroadcastScalarToVector128(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_broadcastb_epi8 (__m128i a)
@@ -395,18 +439,62 @@ namespace System.Runtime.Intrinsics.X86
         /// <summary>
         /// __m256i _mm256_broadcastb_epi8 (__m128i a)
         ///   VPBROADCASTB ymm, xmm
+        /// </summary>
+        public static Vector256<byte> BroadcastScalarToVector256(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_broadcastb_epi8 (__m128i a)
+        ///   VPBROADCASTB ymm, xmm
+        /// </summary>
+        public static Vector256<sbyte> BroadcastScalarToVector256(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_broadcastw_epi16 (__m128i a)
+        ///   VPBROADCASTW ymm, xmm
+        /// </summary>
+        public static Vector256<short> BroadcastScalarToVector256(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m256i _mm256_broadcastw_epi16 (__m128i a)
         ///   VPBROADCASTW ymm, xmm
+        /// </summary>
+        public static Vector256<ushort> BroadcastScalarToVector256(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m256i _mm256_broadcastd_epi32 (__m128i a)
         ///   VPBROADCASTD ymm, xmm
+        /// </summary>
+        public static Vector256<int> BroadcastScalarToVector256(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_broadcastd_epi32 (__m128i a)
+        ///   VPBROADCASTD ymm, xmm
+        /// </summary>
+        public static Vector256<uint> BroadcastScalarToVector256(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m256i _mm256_broadcastq_epi64 (__m128i a)
         ///   VPBROADCASTQ ymm, xmm
+        /// </summary>
+        public static Vector256<long> BroadcastScalarToVector256(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m256i _mm256_broadcastq_epi64 (__m128i a)
+        ///   VPBROADCASTQ ymm, xmm
+        /// </summary>
+        public static Vector256<ulong> BroadcastScalarToVector256(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m256 _mm256_broadcastss_ps (__m128 a)
         ///   VBROADCASTSS ymm, xmm
+        /// </summary>
+        public static Vector256<float> BroadcastScalarToVector256(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m256d _mm256_broadcastsd_pd (__m128d a)
         ///   VBROADCASTSD ymm, xmm
         /// </summary>
-        public static Vector256<T> BroadcastScalarToVector256<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> BroadcastScalarToVector256(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_broadcastb_epi8 (__m128i a)
@@ -652,7 +740,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
         // <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -663,7 +751,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -674,7 +762,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<short> ExtractVector128(Vector256<short> value, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector128<short> ExtractVector128(Vector256<short> value, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -685,7 +773,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -696,7 +784,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<int> ExtractVector128(Vector256<int> value, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector128<int> ExtractVector128(Vector256<int> value, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -707,7 +795,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -718,7 +806,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<long> ExtractVector128(Vector256<long> value, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector128<long> ExtractVector128(Vector256<long> value, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -729,7 +817,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -1064,7 +1152,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xm128, imm8
@@ -1075,7 +1163,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -1086,7 +1174,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -1097,7 +1185,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -1108,7 +1196,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -1480,42 +1568,42 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) { throw new PlatformNotSupportedException(); }
+        public new static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)
diff --git a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx2.cs b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx2.cs
index afaac46be7..a75cf32a2a 100644
--- a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx2.cs
+++ b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Avx2.cs
@@ -326,18 +326,62 @@ namespace System.Runtime.Intrinsics.X86
         /// <summary>
         /// __m128i _mm_broadcastb_epi8 (__m128i a)
         ///   VPBROADCASTB xmm, xmm
+        /// </summary>
+        public static Vector128<byte> BroadcastScalarToVector128(Vector128<byte> value) => BroadcastScalarToVector128(value);
+
+        /// <summary>
+        /// __m128i _mm_broadcastb_epi8 (__m128i a)
+        ///   VPBROADCASTB xmm, xmm
+        /// </summary>
+        public static Vector128<sbyte> BroadcastScalarToVector128(Vector128<sbyte> value) => BroadcastScalarToVector128(value);
+
+        /// <summary>
+        /// __m128i _mm_broadcastw_epi16 (__m128i a)
+        ///   VPBROADCASTW xmm, xmm
+        /// </summary>
+        public static Vector128<short> BroadcastScalarToVector128(Vector128<short> value) => BroadcastScalarToVector128(value);
+
+        /// <summary>
         /// __m128i _mm_broadcastw_epi16 (__m128i a)
         ///   VPBROADCASTW xmm, xmm
+        /// </summary>
+        public static Vector128<ushort> BroadcastScalarToVector128(Vector128<ushort> value) => BroadcastScalarToVector128(value);
+
+        /// <summary>
         /// __m128i _mm_broadcastd_epi32 (__m128i a)
         ///   VPBROADCASTD xmm, xmm
+        /// </summary>
+        public static Vector128<int> BroadcastScalarToVector128(Vector128<int> value) => BroadcastScalarToVector128(value);
+
+        /// <summary>
+        /// __m128i _mm_broadcastd_epi32 (__m128i a)
+        ///   VPBROADCASTD xmm, xmm
+        /// </summary>
+        public static Vector128<uint> BroadcastScalarToVector128(Vector128<uint> value) => BroadcastScalarToVector128(value);
+
+        /// <summary>
         /// __m128i _mm_broadcastq_epi64 (__m128i a)
         ///   VPBROADCASTQ xmm, xmm
+        /// </summary>
+        public static Vector128<long> BroadcastScalarToVector128(Vector128<long> value) => BroadcastScalarToVector128(value);
+
+        /// <summary>
+        /// __m128i _mm_broadcastq_epi64 (__m128i a)
+        ///   VPBROADCASTQ xmm, xmm
+        /// </summary>
+        public static Vector128<ulong> BroadcastScalarToVector128(Vector128<ulong> value) => BroadcastScalarToVector128(value);
+
+        /// <summary>
         /// __m128 _mm_broadcastss_ps (__m128 a)
         ///   VBROADCASTSS xmm, xmm
+        /// </summary>
+        public static Vector128<float> BroadcastScalarToVector128(Vector128<float> value) => BroadcastScalarToVector128(value);
+
+        /// <summary>
         /// __m128d _mm_broadcastsd_pd (__m128d a)
         ///   VMOVDDUP xmm, xmm
         /// </summary>
-        public static Vector128<T> BroadcastScalarToVector128<T>(Vector128<T> value) where T : struct => BroadcastScalarToVector128<T>(value);
+        public static Vector128<double> BroadcastScalarToVector128(Vector128<double> value) => BroadcastScalarToVector128(value);
 
         /// <summary>
         /// __m128i _mm_broadcastb_epi8 (__m128i a)
@@ -394,18 +438,62 @@ namespace System.Runtime.Intrinsics.X86
         /// <summary>
         /// __m256i _mm256_broadcastb_epi8 (__m128i a)
         ///   VPBROADCASTB ymm, xmm
+        /// </summary>
+        public static Vector256<byte> BroadcastScalarToVector256(Vector128<byte> value) => BroadcastScalarToVector256(value);
+
+        /// <summary>
+        /// __m256i _mm256_broadcastb_epi8 (__m128i a)
+        ///   VPBROADCASTB ymm, xmm
+        /// </summary>
+        public static Vector256<sbyte> BroadcastScalarToVector256(Vector128<sbyte> value) => BroadcastScalarToVector256(value);
+
+        /// <summary>
+        /// __m256i _mm256_broadcastw_epi16 (__m128i a)
+        ///   VPBROADCASTW ymm, xmm
+        /// </summary>
+        public static Vector256<short> BroadcastScalarToVector256(Vector128<short> value) => BroadcastScalarToVector256(value);
+
+        /// <summary>
         /// __m256i _mm256_broadcastw_epi16 (__m128i a)
         ///   VPBROADCASTW ymm, xmm
+        /// </summary>
+        public static Vector256<ushort> BroadcastScalarToVector256(Vector128<ushort> value) => BroadcastScalarToVector256(value);
+
+        /// <summary>
         /// __m256i _mm256_broadcastd_epi32 (__m128i a)
         ///   VPBROADCASTD ymm, xmm
+        /// </summary>
+        public static Vector256<int> BroadcastScalarToVector256(Vector128<int> value) => BroadcastScalarToVector256(value);
+
+        /// <summary>
+        /// __m256i _mm256_broadcastd_epi32 (__m128i a)
+        ///   VPBROADCASTD ymm, xmm
+        /// </summary>
+        public static Vector256<uint> BroadcastScalarToVector256(Vector128<uint> value) => BroadcastScalarToVector256(value);
+
+        /// <summary>
         /// __m256i _mm256_broadcastq_epi64 (__m128i a)
         ///   VPBROADCASTQ ymm, xmm
+        /// </summary>
+        public static Vector256<long> BroadcastScalarToVector256(Vector128<long> value) => BroadcastScalarToVector256(value);
+
+        /// <summary>
+        /// __m256i _mm256_broadcastq_epi64 (__m128i a)
+        ///   VPBROADCASTQ ymm, xmm
+        /// </summary>
+        public static Vector256<ulong> BroadcastScalarToVector256(Vector128<ulong> value) => BroadcastScalarToVector256(value);
+
+        /// <summary>
         /// __m256 _mm256_broadcastss_ps (__m128 a)
         ///   VBROADCASTSS ymm, xmm
+        /// </summary>
+        public static Vector256<float> BroadcastScalarToVector256(Vector128<float> value) => BroadcastScalarToVector256(value);
+
+        /// <summary>
         /// __m256d _mm256_broadcastsd_pd (__m128d a)
         ///   VBROADCASTSD ymm, xmm
         /// </summary>
-        public static Vector256<T> BroadcastScalarToVector256<T>(Vector128<T> value) where T : struct => BroadcastScalarToVector256<T>(value);
+        public static Vector256<double> BroadcastScalarToVector256(Vector128<double> value) => BroadcastScalarToVector256(value);
 
         /// <summary>
         /// __m256i _mm256_broadcastb_epi8 (__m128i a)
@@ -651,7 +739,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) => ExtractVector128(value, index);
+        public new static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) => ExtractVector128(value, index);
         // <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -662,7 +750,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) => ExtractVector128(value, index);
+        public new static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) => ExtractVector128(value, index);
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -673,7 +761,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<short> ExtractVector128(Vector256<short> value, byte index) => ExtractVector128(value, index);
+        public new static Vector128<short> ExtractVector128(Vector256<short> value, byte index) => ExtractVector128(value, index);
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -684,7 +772,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) => ExtractVector128(value, index);
+        public new static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) => ExtractVector128(value, index);
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -695,7 +783,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<int> ExtractVector128(Vector256<int> value, byte index) => ExtractVector128(value, index);
+        public new static Vector128<int> ExtractVector128(Vector256<int> value, byte index) => ExtractVector128(value, index);
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -706,7 +794,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) => ExtractVector128(value, index);
+        public new static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) => ExtractVector128(value, index);
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -717,7 +805,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<long> ExtractVector128(Vector256<long> value, byte index) => ExtractVector128(value, index);
+        public new static Vector128<long> ExtractVector128(Vector256<long> value, byte index) => ExtractVector128(value, index);
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -728,7 +816,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) => ExtractVector128(value, index);
+        public new static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) => ExtractVector128(value, index);
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 m128, ymm, imm8
@@ -1783,7 +1871,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index) => InsertVector128(value, data, index);
+        public new static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index) => InsertVector128(value, data, index);
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xm128, imm8
@@ -1794,7 +1882,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index) => InsertVector128(value, data, index);
+        public new static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index) => InsertVector128(value, data, index);
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -1805,7 +1893,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index) => InsertVector128(value, data, index);
+        public new static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index) => InsertVector128(value, data, index);
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -1816,7 +1904,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index) => InsertVector128(value, data, index);
+        public new static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index) => InsertVector128(value, data, index);
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -1827,7 +1915,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index) => InsertVector128(value, data, index);
+        public new static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index) => InsertVector128(value, data, index);
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -1838,7 +1926,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index) => InsertVector128(value, data, index);
+        public new static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index) => InsertVector128(value, data, index);
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -1849,7 +1937,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index) => InsertVector128(value, data, index);
+        public new static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index) => InsertVector128(value, data, index);
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -1860,7 +1948,7 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index) => InsertVector128(value, data, index);
+        public new static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index) => InsertVector128(value, data, index);
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, m128, imm8
@@ -2199,42 +2287,42 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) => Permute2x128(left, right, control);
+        public new static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) => Permute2x128(left, right, control);
+        public new static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) => Permute2x128(left, right, control);
+        public new static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) => Permute2x128(left, right, control);
+        public new static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) => Permute2x128(left, right, control);
+        public new static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) => Permute2x128(left, right, control);
+        public new static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) => Permute2x128(left, right, control);
+        public new static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) => Permute2x128(left, right, control);
+        public new static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)