diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.PlatformNotSupported.cs
index 33f194424bc9e6..197890ebdf8a55 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.PlatformNotSupported.cs
@@ -1678,15 +1678,17 @@ internal Avx10v1() { }
         public static Vector256<sbyte> MultiShift(Vector256<sbyte> control, Vector256<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi16 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<short> PermuteVar16x16(Vector256<short> left, Vector256<short> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi16 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<ushort> PermuteVar16x16(Vector256<ushort> left, Vector256<ushort> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
@@ -1704,15 +1706,17 @@ internal Avx10v1() { }
         public static Vector256<ushort> PermuteVar16x16x2(Vector256<ushort> lower, Vector256<ushort> indices, Vector256<ushort> upper) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b)</para>
+        ///   <para>__m128i _mm_permutexvar_epi8 (__m128i idx, __m128i a)</para>
         ///   <para>  VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector128<byte> PermuteVar16x8(Vector128<byte> left, Vector128<byte> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b)</para>
+        ///   <para>__m128i _mm_permutexvar_epi8 (__m128i idx, __m128i a)</para>
         ///   <para>  VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector128<sbyte> PermuteVar16x8(Vector128<sbyte> left, Vector128<sbyte> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
@@ -1751,15 +1755,17 @@ internal Avx10v1() { }
         public static Vector128<ulong> PermuteVar2x64x2(Vector128<ulong> lower, Vector128<ulong> indices, Vector128<ulong> upper) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi8 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<byte> PermuteVar32x8(Vector256<byte> left, Vector256<byte> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi8 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<sbyte> PermuteVar32x8(Vector256<sbyte> left, Vector256<sbyte> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
@@ -1804,15 +1810,17 @@ internal Avx10v1() { }
         public static Vector256<double> PermuteVar4x64(Vector256<double> value, Vector256<long> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi64 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<long> PermuteVar4x64(Vector256<long> value, Vector256<long> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m256i _mm256_permute4x64_pd (__m256d a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi64 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<ulong> PermuteVar4x64(Vector256<ulong> value, Vector256<ulong> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
@@ -1837,15 +1845,17 @@ internal Avx10v1() { }
         public static Vector256<ulong> PermuteVar4x64x2(Vector256<ulong> lower, Vector256<ulong> indices, Vector256<ulong> upper) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b)</para>
+        ///   <para>__m128i _mm_permutexvar_epi16 (__m128i idx, __m128i a)</para>
         ///   <para>  VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector128<short> PermuteVar8x16(Vector128<short> left, Vector128<short> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b)</para>
+        ///   <para>__m128i _mm_permutexvar_epi16 (__m128i idx, __m128i a)</para>
         ///   <para>  VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector128<ushort> PermuteVar8x16(Vector128<ushort> left, Vector128<ushort> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
@@ -3168,15 +3178,17 @@ internal V512() { }
             public static Vector512<double> Xor(Vector512<double> left, Vector512<double> right) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   <para>__m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b)</para>
+            ///   <para>__m512i _mm512_permutexvar_epi8 (__m512i idx, __m512i a)</para>
             ///   <para>  VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector512<sbyte> PermuteVar64x8(Vector512<sbyte> left, Vector512<sbyte> control) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   <para>__m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b)</para>
+            ///   <para>__m512i _mm512_permutexvar_epi8 (__m512i idx, __m512i a)</para>
             ///   <para>  VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector512<byte> PermuteVar64x8(Vector512<byte> left, Vector512<byte> control) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.cs
index 7cd16c3ae3f4ce..831edf4073ba5c 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.cs
@@ -1677,15 +1677,17 @@ internal Avx10v1() { }
         public static Vector256<sbyte> MultiShift(Vector256<sbyte> control, Vector256<long> value) => MultiShift(control, value);
 
         /// <summary>
-        ///   <para>__m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi16 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<short> PermuteVar16x16(Vector256<short> left, Vector256<short> control) => PermuteVar16x16(left, control);
 
         /// <summary>
-        ///   <para>__m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi16 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<ushort> PermuteVar16x16(Vector256<ushort> left, Vector256<ushort> control) => PermuteVar16x16(left, control);
 
         /// <summary>
@@ -1703,15 +1705,17 @@ internal Avx10v1() { }
         public static Vector256<ushort> PermuteVar16x16x2(Vector256<ushort> lower, Vector256<ushort> indices, Vector256<ushort> upper) => PermuteVar16x16x2(lower, indices, upper);
 
         /// <summary>
-        ///   <para>__m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b)</para>
+        ///   <para>__m128i _mm_permutexvar_epi8 (__m128i idx, __m128i a)</para>
         ///   <para>  VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector128<byte> PermuteVar16x8(Vector128<byte> left, Vector128<byte> control) => PermuteVar16x8(left, control);
 
         /// <summary>
-        ///   <para>__m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b)</para>
+        ///   <para>__m128i _mm_permutexvar_epi8 (__m128i idx, __m128i a)</para>
         ///   <para>  VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector128<sbyte> PermuteVar16x8(Vector128<sbyte> left, Vector128<sbyte> control) => PermuteVar16x8(left, control);
 
         /// <summary>
@@ -1750,15 +1754,17 @@ internal Avx10v1() { }
         public static Vector128<ulong> PermuteVar2x64x2(Vector128<ulong> lower, Vector128<ulong> indices, Vector128<ulong> upper) => PermuteVar2x64x2(lower, indices, upper);
 
         /// <summary>
-        ///   <para>__m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi8 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<byte> PermuteVar32x8(Vector256<byte> left, Vector256<byte> control) => PermuteVar32x8(left, control);
 
         /// <summary>
-        ///   <para>__m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi8 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<sbyte> PermuteVar32x8(Vector256<sbyte> left, Vector256<sbyte> control) => PermuteVar32x8(left, control);
 
         /// <summary>
@@ -1803,15 +1809,17 @@ internal Avx10v1() { }
         public static Vector256<double> PermuteVar4x64(Vector256<double> value, Vector256<long> control) => PermuteVar4x64(value, control);
 
         /// <summary>
-        ///   <para>__m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi64 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<long> PermuteVar4x64(Vector256<long> value, Vector256<long> control) => PermuteVar4x64(value, control);
 
         /// <summary>
-        ///   <para>__m256i _mm256_permute4x64_pd (__m256d a, __m256i b)</para>
+        ///   <para>__m256i _mm256_permutexvar_epi64 (__m256i idx, __m256i a)</para>
         ///   <para>  VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector256<ulong> PermuteVar4x64(Vector256<ulong> value, Vector256<ulong> control) => PermuteVar4x64(value, control);
 
         /// <summary>
@@ -1836,15 +1844,17 @@ internal Avx10v1() { }
         public static Vector256<ulong> PermuteVar4x64x2(Vector256<ulong> lower, Vector256<ulong> indices, Vector256<ulong> upper) => PermuteVar4x64x2(lower, indices, upper);
 
         /// <summary>
-        ///   <para>__m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b)</para>
+        ///   <para>__m128i _mm_permutexvar_epi16 (__m128i idx, __m128i a)</para>
         ///   <para>  VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector128<short> PermuteVar8x16(Vector128<short> left, Vector128<short> control) => PermuteVar8x16(left, control);
 
         /// <summary>
-        ///   <para>__m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b)</para>
+        ///   <para>__m128i _mm_permutexvar_epi16 (__m128i idx, __m128i a)</para>
         ///   <para>  VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector128<ushort> PermuteVar8x16(Vector128<ushort> left, Vector128<ushort> control) => PermuteVar8x16(left, control);
 
         /// <summary>
@@ -3158,15 +3168,17 @@ internal V512() { }
             public static Vector512<double> Xor(Vector512<double> left, Vector512<double> right) => Xor(left, right);
 
             /// <summary>
-            ///   <para>__m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b)</para>
+            ///   <para>__m512i _mm512_permutexvar_epi8 (__m512i idx, __m512i a)</para>
             ///   <para>  VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector512<sbyte> PermuteVar64x8(Vector512<sbyte> left, Vector512<sbyte> control) => PermuteVar64x8(left, control);
 
             /// <summary>
-            ///   <para>__m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b)</para>
+            ///   <para>__m512i _mm512_permutexvar_epi8 (__m512i idx, __m512i a)</para>
             ///   <para>  VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector512<byte> PermuteVar64x8(Vector512<byte> left, Vector512<byte> control) => PermuteVar64x8(left, control);
 
             /// <summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
index bacca0da37377f..b8d03d4f576fe9 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
@@ -1710,20 +1710,20 @@ internal X64() { }
 
         /// <summary>
         ///   <para>__m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)</para>
-        ///   <para>  VPERMD ymm1,         ymm2/m256,         imm8</para>
-        ///   <para>  VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8</para>
+        ///   <para>  VPERMD ymm1,         ymm2, ymm3/m256,       </para>
+        ///   <para>  VPERMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst</para>
         /// </summary>
         public static Vector256<int> PermuteVar8x32(Vector256<int> left, Vector256<int> control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         ///   <para>__m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)</para>
-        ///   <para>  VPERMD ymm1,         ymm2/m256,         imm8</para>
-        ///   <para>  VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8</para>
+        ///   <para>  VPERMD ymm1,         ymm2, ymm3/m256,       </para>
+        ///   <para>  VPERMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst</para>
         /// </summary>
         public static Vector256<uint> PermuteVar8x32(Vector256<uint> left, Vector256<uint> control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         ///   <para>__m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx)</para>
-        ///   <para>  VPERMPS ymm1,         ymm2/m256,         imm8</para>
-        ///   <para>  VPERMPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8</para>
+        ///   <para>  VPERMPS ymm1,         ymm2, ymm3/m256,       </para>
+        ///   <para>  VPERMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst</para>
         /// </summary>
         public static Vector256<float> PermuteVar8x32(Vector256<float> left, Vector256<int> control) { throw new PlatformNotSupportedException(); }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs
index 05ee3126de3298..edf6fefcda7ed3 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs
@@ -2190,20 +2190,20 @@ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> sou
 
         /// <summary>
         ///   <para>__m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)</para>
-        ///   <para>  VPERMD ymm1,         ymm2/m256,         imm8</para>
-        ///   <para>  VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8</para>
+        ///   <para>  VPERMD ymm1,         ymm2, ymm3/m256,       </para>
+        ///   <para>  VPERMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst</para>
         /// </summary>
         public static Vector256<int> PermuteVar8x32(Vector256<int> left, Vector256<int> control) => PermuteVar8x32(left, control);
         /// <summary>
         ///   <para>__m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)</para>
-        ///   <para>  VPERMD ymm1,         ymm2/m256,         imm8</para>
-        ///   <para>  VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8</para>
+        ///   <para>  VPERMD ymm1,         ymm2, ymm3/m256,       </para>
+        ///   <para>  VPERMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst</para>
         /// </summary>
         public static Vector256<uint> PermuteVar8x32(Vector256<uint> left, Vector256<uint> control) => PermuteVar8x32(left, control);
         /// <summary>
         ///   <para>__m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx)</para>
-        ///   <para>  VPERMPS ymm1,         ymm2/m256,         imm8</para>
-        ///   <para>  VPERMPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8</para>
+        ///   <para>  VPERMPS ymm1,         ymm2, ymm3/m256,       </para>
+        ///   <para>  VPERMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst</para>
         /// </summary>
         public static Vector256<float> PermuteVar8x32(Vector256<float> left, Vector256<int> control) => PermuteVar8x32(left, control);
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.PlatformNotSupported.cs
index 7cc4d2ef352057..9c544203d5f1f8 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.PlatformNotSupported.cs
@@ -281,14 +281,16 @@ internal VL() { }
             public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<short> value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   <para>__m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b)</para>
+            ///   <para>__m128i _mm_permutexvar_epi16 (__m128i idx, __m128i a)</para>
             ///   <para>  VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector128<short> PermuteVar8x16(Vector128<short> left, Vector128<short> control) { throw new PlatformNotSupportedException(); }
             /// <summary>
-            ///   <para>__m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b)</para>
+            ///   <para>__m128i _mm_permutexvar_epi16 (__m128i idx, __m128i a)</para>
             ///   <para>  VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector128<ushort> PermuteVar8x16(Vector128<ushort> left, Vector128<ushort> control) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
@@ -305,14 +307,16 @@ internal VL() { }
             public static Vector128<ushort> PermuteVar8x16x2(Vector128<ushort> lower, Vector128<ushort> indices, Vector128<ushort> upper) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   <para>__m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi16 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<short> PermuteVar16x16(Vector256<short> left, Vector256<short> control) { throw new PlatformNotSupportedException(); }
             /// <summary>
-            ///   <para>__m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi16 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<ushort> PermuteVar16x16(Vector256<ushort> left, Vector256<ushort> control) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
@@ -823,14 +827,16 @@ internal X64() { }
         public static Vector512<ushort> PackUnsignedSaturate(Vector512<int> left, Vector512<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi16 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<short> PermuteVar32x16(Vector512<short> left, Vector512<short> control) { throw new PlatformNotSupportedException(); }
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi16 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<ushort> PermuteVar32x16(Vector512<ushort> left, Vector512<ushort> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.cs
index 64d393d83556b3..ee4ba665e017ac 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.cs
@@ -280,14 +280,16 @@ internal VL() { }
             public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<short> value) => ConvertToVector128SByteWithSaturation(value);
 
             /// <summary>
-            ///   <para>__m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b)</para>
+            ///   <para>__m128i _mm_permutexvar_epi16 (__m128i idx, __m128i a)</para>
             ///   <para>  VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector128<short> PermuteVar8x16(Vector128<short> left, Vector128<short> control) => PermuteVar8x16(left, control);
             /// <summary>
-            ///   <para>__m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b)</para>
+            ///   <para>__m128i _mm_permutexvar_epi16 (__m128i idx, __m128i a)</para>
             ///   <para>  VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector128<ushort> PermuteVar8x16(Vector128<ushort> left, Vector128<ushort> control) => PermuteVar8x16(left, control);
 
             /// <summary>
@@ -304,14 +306,16 @@ internal VL() { }
             public static Vector128<ushort> PermuteVar8x16x2(Vector128<ushort> lower, Vector128<ushort> indices, Vector128<ushort> upper) => PermuteVar8x16x2(lower, indices, upper);
 
             /// <summary>
-            ///   <para>__m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi16 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<short> PermuteVar16x16(Vector256<short> left, Vector256<short> control) => PermuteVar16x16(left, control);
             /// <summary>
-            ///   <para>__m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi16 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<ushort> PermuteVar16x16(Vector256<ushort> left, Vector256<ushort> control) => PermuteVar16x16(left, control);
 
             /// <summary>
@@ -823,14 +827,16 @@ internal X64() { }
         public static Vector512<ushort> PackUnsignedSaturate(Vector512<int> left, Vector512<int> right) => PackUnsignedSaturate(left, right);
 
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi16 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<short> PermuteVar32x16(Vector512<short> left, Vector512<short> control) => PermuteVar32x16(left, control);
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi16 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<ushort> PermuteVar32x16(Vector512<ushort> left, Vector512<ushort> control) => PermuteVar32x16(left, control);
 
         /// <summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.PlatformNotSupported.cs
index 44d43475b5dbd0..2be6df6ff3679d 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.PlatformNotSupported.cs
@@ -783,19 +783,22 @@ internal VL() { }
             public static Vector128<float> PermuteVar4x32x2(Vector128<float> lower, Vector128<int> indices, Vector128<float> upper) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   <para>__m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi64 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<long> PermuteVar4x64(Vector256<long> value, Vector256<long> control) { throw new PlatformNotSupportedException(); }
             /// <summary>
-            ///   <para>__m256i _mm256_permute4x64_pd (__m256d a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi64 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<ulong> PermuteVar4x64(Vector256<ulong> value, Vector256<ulong> control) { throw new PlatformNotSupportedException(); }
             /// <summary>
-            ///   <para>__m256d _mm256_permute4x64_pd (__m256d a, __m256i b)</para>
+            ///   <para>__m256d _mm256_permutexvar_pd (__m256i idx, __m256d a)</para>
             ///   <para>  VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<double> PermuteVar4x64(Vector256<double> value, Vector256<long> control) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
@@ -3171,19 +3174,22 @@ internal X64() { }
         public static Vector512<float> PermuteVar4x32(Vector512<float> left, Vector512<int> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi64 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<long> PermuteVar8x64(Vector512<long> value, Vector512<long> control) { throw new PlatformNotSupportedException(); }
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi64 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<ulong> PermuteVar8x64(Vector512<ulong> value, Vector512<ulong> control) { throw new PlatformNotSupportedException(); }
         /// <summary>
-        ///   <para>__m512d _mm512_permutevar8x64_pd (__m512d a, __m512i b)</para>
+        ///   <para>__m512d _mm512_permutexvar_pd (__m512i idx, __m512d a)</para>
         ///   <para>  VPERMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<double> PermuteVar8x64(Vector512<double> value, Vector512<long> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
@@ -3206,19 +3212,22 @@ internal X64() { }
         public static Vector512<double> PermuteVar8x64x2(Vector512<double> lower, Vector512<long> indices, Vector512<double> upper) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi32 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<int> PermuteVar16x32(Vector512<int> left, Vector512<int> control) { throw new PlatformNotSupportedException(); }
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi32 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<uint> PermuteVar16x32(Vector512<uint> left, Vector512<uint> control) { throw new PlatformNotSupportedException(); }
         /// <summary>
-        ///   <para>__m512 _mm512_permutevar16x32_ps (__m512 a, __m512i b)</para>
+        ///   <para>__m512 _mm512_permutexvar_ps (__m512i idx, __m512 a)</para>
         ///   <para>  VPERMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<float> PermuteVar16x32(Vector512<float> left, Vector512<int> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.cs
index 17074e9f7aa93a..e7752d8814b363 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.cs
@@ -783,19 +783,22 @@ internal VL() { }
             public static Vector128<float> PermuteVar4x32x2(Vector128<float> lower, Vector128<int> indices, Vector128<float> upper) => PermuteVar4x32x2(lower, indices, upper);
 
             /// <summary>
-            ///   <para>__m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi64 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<long> PermuteVar4x64(Vector256<long> value, Vector256<long> control) => PermuteVar4x64(value, control);
             /// <summary>
-            ///   <para>__m256i _mm256_permute4x64_pd (__m256d a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi64 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<ulong> PermuteVar4x64(Vector256<ulong> value, Vector256<ulong> control) => PermuteVar4x64(value, control);
             /// <summary>
-            ///   <para>__m256d _mm256_permute4x64_pd (__m256d a, __m256i b)</para>
+            ///   <para>__m256d _mm256_permutexvar_pd (__m256i idx, __m256d a)</para>
             ///   <para>  VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<double> PermuteVar4x64(Vector256<double> value, Vector256<long> control) => PermuteVar4x64(value, control);
 
             /// <summary>
@@ -3177,19 +3180,22 @@ internal X64() { }
         public static Vector512<float> PermuteVar4x32(Vector512<float> left, Vector512<int> control) => PermuteVar4x32(left, control);
 
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi64 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<long> PermuteVar8x64(Vector512<long> value, Vector512<long> control) => PermuteVar8x64(value, control);
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi64 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<ulong> PermuteVar8x64(Vector512<ulong> value, Vector512<ulong> control) => PermuteVar8x64(value, control);
         /// <summary>
-        ///   <para>__m512d _mm512_permutevar8x64_pd (__m512d a, __m512i b)</para>
+        ///   <para>__m512d _mm512_permutexvar_pd (__m512i idx, __m512d a)</para>
         ///   <para>  VPERMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<double> PermuteVar8x64(Vector512<double> value, Vector512<long> control) => PermuteVar8x64(value, control);
 
         /// <summary>
@@ -3212,19 +3218,22 @@ internal X64() { }
         public static Vector512<double> PermuteVar8x64x2(Vector512<double> lower, Vector512<long> indices, Vector512<double> upper) => PermuteVar8x64x2(lower, indices, upper);
 
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi32 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<int> PermuteVar16x32(Vector512<int> left, Vector512<int> control) => PermuteVar16x32(left, control);
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi32 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<uint> PermuteVar16x32(Vector512<uint> left, Vector512<uint> control) => PermuteVar16x32(left, control);
         /// <summary>
-        ///   <para>__m512 _mm512_permutevar16x32_ps (__m512 a, __m512i b)</para>
+        ///   <para>__m512 _mm512_permutexvar_ps (__m512i idx, __m512 a)</para>
         ///   <para>  VPERMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<float> PermuteVar16x32(Vector512<float> left, Vector512<int> control) => PermuteVar16x32(left, control);
 
         /// <summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.PlatformNotSupported.cs
index 7262ada388b819..521baaed8a910b 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.PlatformNotSupported.cs
@@ -50,14 +50,16 @@ internal VL() { }
             public static Vector256<sbyte> MultiShift(Vector256<sbyte> control, Vector256<long> value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   <para>__m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b)</para>
+            ///   <para>__m128i _mm_permutexvar_epi8 (__m128i idx, __m128i a)</para>
             ///   <para>  VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector128<sbyte> PermuteVar16x8(Vector128<sbyte> left, Vector128<sbyte> control) { throw new PlatformNotSupportedException(); }
             /// <summary>
-            ///   <para>__m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b)</para>
+            ///   <para>__m128i _mm_permutexvar_epi8 (__m128i idx, __m128i a)</para>
             ///   <para>  VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector128<byte> PermuteVar16x8(Vector128<byte> left, Vector128<byte> control) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
@@ -74,14 +76,16 @@ internal VL() { }
             public static Vector128<sbyte> PermuteVar16x8x2(Vector128<sbyte> lower, Vector128<sbyte> indices, Vector128<sbyte> upper) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   <para>__m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi8 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<sbyte> PermuteVar32x8(Vector256<sbyte> left, Vector256<sbyte> control) { throw new PlatformNotSupportedException(); }
             /// <summary>
-            ///   <para>__m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi8 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<byte> PermuteVar32x8(Vector256<byte> left, Vector256<byte> control) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
@@ -121,14 +125,16 @@ internal X64() { }
         public static Vector512<sbyte> MultiShift(Vector512<sbyte> control, Vector512<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi8 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<sbyte> PermuteVar64x8(Vector512<sbyte> left, Vector512<sbyte> control) { throw new PlatformNotSupportedException(); }
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi8 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<byte> PermuteVar64x8(Vector512<byte> left, Vector512<byte> control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.cs
index 6d4c48db2519ba..17f6ae51976fa6 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.cs
@@ -54,14 +54,16 @@ internal VL() { }
             public static Vector256<sbyte> MultiShift(Vector256<sbyte> control, Vector256<long> value) => MultiShift(control, value);
 
             /// <summary>
-            ///   <para>__m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b)</para>
+            ///   <para>__m128i _mm_permutexvar_epi8 (__m128i idx, __m128i a)</para>
             ///   <para>  VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector128<sbyte> PermuteVar16x8(Vector128<sbyte> left, Vector128<sbyte> control) => PermuteVar16x8(left, control);
             /// <summary>
-            ///   <para>__m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b)</para>
+            ///   <para>__m128i _mm_permutexvar_epi8 (__m128i idx, __m128i a)</para>
             ///   <para>  VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector128<byte> PermuteVar16x8(Vector128<byte> left, Vector128<byte> control) => PermuteVar16x8(left, control);
 
             /// <summary>
@@ -78,14 +80,16 @@ internal VL() { }
             public static Vector128<sbyte> PermuteVar16x8x2(Vector128<sbyte> lower, Vector128<sbyte> indices, Vector128<sbyte> upper) => PermuteVar16x8x2(lower, indices, upper);
 
             /// <summary>
-            ///   <para>__m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi8 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<sbyte> PermuteVar32x8(Vector256<sbyte> left, Vector256<sbyte> control) => PermuteVar32x8(left, control);
             /// <summary>
-            ///   <para>__m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b)</para>
+            ///   <para>__m256i _mm256_permutexvar_epi8 (__m256i idx, __m256i a)</para>
             ///   <para>  VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256</para>
             /// </summary>
+            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
             public static Vector256<byte> PermuteVar32x8(Vector256<byte> left, Vector256<byte> control) => PermuteVar32x8(left, control);
 
             /// <summary>
@@ -126,14 +130,16 @@ internal X64() { }
         public static Vector512<sbyte> MultiShift(Vector512<sbyte> control, Vector512<long> value) => MultiShift(control, value);
 
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi8 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<sbyte> PermuteVar64x8(Vector512<sbyte> left, Vector512<sbyte> control) => PermuteVar64x8(left, control);
         /// <summary>
-        ///   <para>__m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b)</para>
+        ///   <para>__m512i _mm512_permutexvar_epi8 (__m512i idx, __m512i a)</para>
         ///   <para>  VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
         /// </summary>
+        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
         public static Vector512<byte> PermuteVar64x8(Vector512<byte> left, Vector512<byte> control) => PermuteVar64x8(left, control);
 
         /// <summary>