Adding scalar hardware intrinsics for x86.

12 files changed, 1181 insertions, 6 deletions

diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs
index 4eb9e3bb03..adf38c32d0 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs
@@ -117,7 +117,21 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8)
         /// </summary>
         public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
-        
+
+        /// <summary>
+        /// __m128d _mm_cmp_sd (__m128d a, __m128d b, const int imm8)
+        /// </summary>
+        public static Vector128<double> CompareScalar(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128 _mm_cmp_ss (__m128 a, __m128 b, const int imm8)
+        /// </summary>
+        public static Vector128<float> CompareScalar(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float _mm256_cvtss_f32 (__m256 a)
+        /// </summary>
+        public static float ConvertToSingle(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
         /// <summary>
         /// __m128i _mm256_cvtpd_epi32 (__m256d a)
         /// </summary>
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.cs
index 725b1c4d62..d2f804b16c 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx.cs
@@ -117,7 +117,21 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8)
         /// </summary>
         public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, FloatComparisonMode mode) => Compare(left, right, mode);
-        
+
+        /// <summary>
+        /// __m128d _mm_cmp_sd (__m128d a, __m128d b, const int imm8)
+        /// </summary>
+        public static Vector128<double> CompareScalar(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) => CompareScalar(left, right, mode);
+        /// <summary>
+        /// __m128 _mm_cmp_ss (__m128 a, __m128 b, const int imm8)
+        /// </summary>
+        public static Vector128<float> CompareScalar(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode) => CompareScalar(left, right, mode);
+
+        /// <summary>
+        /// float _mm256_cvtss_f32 (__m256 a)
+        /// </summary>
+        public static float ConvertToSingle(Vector256<float> value) => ConvertToSingle(value);
+
         /// <summary>
         /// __m128i _mm256_cvtpd_epi32 (__m256d a)
         /// </summary>
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
index 97e1074ef6..c7ea1db42f 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
@@ -296,6 +296,19 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// double _mm256_cvtsd_f64 (__m256d a)
+        /// </summary>
+        public static double ConvertToDouble(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// int _mm256_cvtsi256_si32 (__m256i a)
+        /// </summary>
+        public static int ConvertToInt32(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// int _mm256_cvtsi256_si32 (__m256i a)
+        /// </summary>
+        public static uint ConvertToUInt32(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m256i _mm256_cvtepi8_epi16 (__m128i a)
         /// </summary>
         public static Vector256<short> ConvertToVector256Short(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.cs
index aef7410af7..76d362b2ae 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Avx2.cs
@@ -304,6 +304,19 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) => CompareGreaterThan(left, right);
 
         /// <summary>
+        /// double _mm256_cvtsd_f64 (__m256d a)
+        /// </summary>
+        public static double ConvertToDouble(Vector256<double> value) => ConvertToDouble(value);
+        /// <summary>
+        /// int _mm256_cvtsi256_si32 (__m256i a)
+        /// </summary>
+        public static int ConvertToInt32(Vector256<int> value) => ConvertToInt32(value);
+        /// <summary>
+        /// int _mm256_cvtsi256_si32 (__m256i a)
+        /// </summary>
+        public static uint ConvertToUInt32(Vector256<uint> value) => ConvertToUInt32(value);
+
+        /// <summary>
         /// __m256i _mm256_cvtepi8_epi16 (__m128i a)
         /// </summary>
         public static Vector256<short> ConvertToVector256Short(Vector128<sbyte> value) => ConvertToVector256Short(value);
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs
index c3adf712f8..2a6c3c9762 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs
@@ -32,6 +32,15 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector256<double> MultiplyAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_fmadd_ss (__m128 a, __m128 b, __m128 c)
+        /// </summary>
+        public static Vector128<float> MultiplyAddScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128d _mm_fmadd_sd (__m128d a, __m128d b, __m128d c)
+        /// </summary>
+        public static Vector128<double> MultiplyAddScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_fmaddsub_ps (__m128 a, __m128 b, __m128 c)
         /// </summary>
         public static Vector128<float> MultiplyAddSubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
@@ -66,6 +75,15 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector256<double> MultiplySubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_fmsub_ss (__m128 a, __m128 b, __m128 c)
+        /// </summary>
+        public static Vector128<float> MultiplySubtractScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128d _mm_fmsub_sd (__m128d a, __m128d b, __m128d c)
+        /// </summary>
+        public static Vector128<double> MultiplySubtractScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_fmsubadd_ps (__m128 a, __m128 b, __m128 c)
         /// </summary>
         public static Vector128<float> MultiplySubtractAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
@@ -99,6 +117,15 @@ namespace System.Runtime.Intrinsics.X86
         /// </summary>
         public static Vector256<double> MultiplyAddNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new PlatformNotSupportedException(); }
 
+                /// <summary>
+        /// __m128 _mm_fnmadd_ss (__m128 a, __m128 b, __m128 c)
+        /// </summary>
+        public static Vector128<float> MultiplyAddNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128d _mm_fnmadd_sd (__m128d a, __m128d b, __m128d c)
+        /// </summary>
+        public static Vector128<double> MultiplyAddNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new PlatformNotSupportedException(); }
+
         /// <summary>
         /// __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c)
         /// </summary>
@@ -115,5 +142,14 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256d _mm256_fnmsub_pd (__m256d a, __m256d b, __m256d c)
         /// </summary>
         public static Vector256<double> MultiplySubtractNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128 _mm_fnmsub_ss (__m128 a, __m128 b, __m128 c)
+        /// </summary>
+        public static Vector128<float> MultiplySubtractNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128d _mm_fnmsub_sd (__m128d a, __m128d b, __m128d c)
+        /// </summary>
+        public static Vector128<double> MultiplySubtractNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new PlatformNotSupportedException(); }
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.cs
index f4d053a078..25561bdb15 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Fma.cs
@@ -32,6 +32,15 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector256<double> MultiplyAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplyAdd(a, b, c);
 
         /// <summary>
+        /// __m128 _mm_fmadd_ss (__m128 a, __m128 b, __m128 c)
+        /// </summary>
+        public static Vector128<float> MultiplyAddScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplyAddScalar(a, b, c);
+        /// <summary>
+        /// __m128d _mm_fmadd_sd (__m128d a, __m128d b, __m128d c)
+        /// </summary>
+        public static Vector128<double> MultiplyAddScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) => MultiplyAddScalar(a, b, c);
+
+        /// <summary>
         /// __m128 _mm_fmaddsub_ps (__m128 a, __m128 b, __m128 c)
         /// </summary>
         public static Vector128<float> MultiplyAddSubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplyAddSubtract(a, b, c);
@@ -66,6 +75,15 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector256<double> MultiplySubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplySubtract(a, b, c);
 
         /// <summary>
+        /// __m128 _mm_fmsub_ss (__m128 a, __m128 b, __m128 c)
+        /// </summary>
+        public static Vector128<float> MultiplySubtractScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplySubtractScalar(a, b, c);
+        /// <summary>
+        /// __m128d _mm_fmsub_sd (__m128d a, __m128d b, __m128d c)
+        /// </summary>
+        public static Vector128<double> MultiplySubtractScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) => MultiplySubtractScalar(a, b, c);
+
+        /// <summary>
         /// __m128 _mm_fmsubadd_ps (__m128 a, __m128 b, __m128 c)
         /// </summary>
         public static Vector128<float> MultiplySubtractAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplySubtractAdd(a, b, c);
@@ -100,6 +118,15 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector256<double> MultiplyAddNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplyAddNegated(a, b, c);
 
         /// <summary>
+        /// __m128 _mm_fnmadd_ss (__m128 a, __m128 b, __m128 c)
+        /// </summary>
+        public static Vector128<float> MultiplyAddNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplyAddNegatedScalar(a, b, c);
+        /// <summary>
+        /// __m128d _mm_fnmadd_sd (__m128d a, __m128d b, __m128d c)
+        /// </summary>
+        public static Vector128<double> MultiplyAddNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) => MultiplyAddNegatedScalar(a, b, c);
+
+        /// <summary>
         /// __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c)
         /// </summary>
         public static Vector128<float> MultiplySubtractNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplySubtractNegated(a, b, c);
@@ -115,5 +142,14 @@ namespace System.Runtime.Intrinsics.X86
         /// __m256d _mm256_fnmsub_pd (__m256d a, __m256d b, __m256d c)
         /// </summary>
         public static Vector256<double> MultiplySubtractNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplySubtractNegated(a, b, c);
+
+        /// <summary>
+        /// __m128 _mm_fnmsub_ss (__m128 a, __m128 b, __m128 c)
+        /// </summary>
+        public static Vector128<float> MultiplySubtractNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplySubtractNegatedScalar(a, b, c);
+        /// <summary>
+        /// __m128d _mm_fnmsub_sd (__m128d a, __m128d b, __m128d c)
+        /// </summary>
+        public static Vector128<double> MultiplySubtractNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) => MultiplySubtractNegatedScalar(a, b, c);
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs
index fa91c5055e..0aa590c56a 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs
@@ -21,6 +21,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> Add(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_add_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> AddScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_and_ps (__m128 a, __m128 b)
         /// </summary>
         public static Vector128<float> And(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
@@ -36,71 +41,232 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> CompareEqual(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comieq_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomieq_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128 _mm_cmpeq_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmpgt_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareGreaterThan(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comigt_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareGreaterThanOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomigt_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareGreaterThanUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128 _mm_cmpgt_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareGreaterThanScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmpge_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comige_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomige_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128 _mm_cmpge_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmplt_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareLessThan(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comilt_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareLessThanOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomilt_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareLessThanUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128 _mm_cmplt_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareLessThanScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmple_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comile_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareLessThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomile_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128 _mm_cmple_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmpneq_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareNotEqual(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_cmpneq_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareNotEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_comineq_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareNotEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomineq_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareNotEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmpngt_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareNotGreaterThan(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_cmpngt_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareNotGreaterThanScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmpnge_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareNotGreaterThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_cmpnge_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareNotGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmpnlt_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareNotLessThan(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_cmpnlt_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareNotLessThanScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmpnle_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareNotLessThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_cmpnle_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareNotLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmpord_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareOrdered(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_cmpord_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_cmpunord_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareUnordered(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
-        
+
+        /// <summary>
+        /// __m128 _mm_cmpunord_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_cvtss_si32 (__m128 a)
+        /// </summary>
+        public static int ConvertToInt32(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __int64 _mm_cvtss_si64 (__m128 a)
+        /// </summary>
+        public static long ConvertToInt64(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// float _mm_cvtss_f32 (__m128 a)
+        /// </summary>
+        public static float ConvertToSingle(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128 _mm_cvtsi32_ss (__m128 a, int b)
+        /// </summary>
+        public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, int value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b)
+        /// </summary>
+        public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, long value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_cvttss_si32 (__m128 a)
+        /// </summary>
+        public static int ConvertToInt32WithTruncation(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __int64 _mm_cvttss_si64 (__m128 a)
+        /// </summary>
+        public static long ConvertToInt64WithTruncation(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
         /// <summary>
         /// __m128 _mm_div_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> Divide(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_div_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> DivideScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_loadu_ps (float const* mem_address)
         /// </summary>
         public static unsafe Vector128<float> Load(float* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_load_ss (float const* mem_address)
+        /// </summary>
+        public static unsafe Vector128<float> LoadScalar(float* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_load_ps (float const* mem_address)
         /// </summary>
         public static unsafe Vector128<float> LoadAligned(float* address) { throw new PlatformNotSupportedException(); }
@@ -111,11 +277,26 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> Max(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_max_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> MaxScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_min_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> Min(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_min_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> MinScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128 _mm_move_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static Vector128<float> MoveScalar(Vector128<float> upper, Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_movehl_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> MoveHighToLow(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
@@ -131,6 +312,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> Multiply(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_mul_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static Vector128<float> MultiplyScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_or_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> Or(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
@@ -141,16 +327,31 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> Reciprocal(Vector128<float> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_rcp_ss (__m128 a)
+        /// </summary>
+        public static Vector128<float> ReciprocalScalar(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_rsqrt_ps (__m128 a)
         /// </summary>
         public static Vector128<float> ReciprocalSquareRoot(Vector128<float> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_rsqrt_ss (__m128 a)
+        /// </summary>
+        public static Vector128<float> ReciprocalSqrtScalar(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_set_ps (float e3, float e2, float e1, float e0)
         /// </summary>
         public static Vector128<float> Set(float e3, float e2, float e1, float e0) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_set_ss (float a)
+        /// </summary>
+        public static Vector128<float> SetScalar(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_set1_ps (float a)
         /// </summary>
         public static Vector128<float> Set1(float value) { throw new PlatformNotSupportedException(); }
@@ -181,6 +382,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> Sqrt(Vector128<float> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_sqrt_ss (__m128 a)
+        /// </summary>
+        public static Vector128<float> SqrtScalar(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// void _mm_store_ps (float* mem_addr, __m128 a)
         /// </summary>
         public static unsafe void StoreAligned(float* address, Vector128<float> source) { throw new PlatformNotSupportedException(); }
@@ -196,11 +402,21 @@ namespace System.Runtime.Intrinsics.X86
         public static unsafe void Store(float* address, Vector128<float> source) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// void _mm_store_ss (float* mem_addr, __m128 a)
+        /// </summary>
+        public static unsafe void StoreScalar(float* address, Vector128<float> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_sub_ps (__m128d a, __m128d b)
         /// </summary>
         public static Vector128<float> Subtract(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128 _mm_sub_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static Vector128<float> SubtractScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128 _mm_unpackhi_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> UnpackHigh(Vector128<float> left,  Vector128<float> right) { throw new PlatformNotSupportedException(); }
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.cs
index 424ffc50a0..87059df96c 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse.cs
@@ -21,6 +21,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> Add(Vector128<float> left, Vector128<float> right) => Add(left, right);
 
         /// <summary>
+        /// __m128 _mm_add_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> AddScalar(Vector128<float> left, Vector128<float> right) => AddScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_and_ps (__m128 a, __m128 b)
         /// </summary>
         public static Vector128<float> And(Vector128<float> left, Vector128<float> right) => And(left, right);
@@ -36,71 +41,232 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> CompareEqual(Vector128<float> left, Vector128<float> right) => CompareEqual(left, right);
 
         /// <summary>
+        /// int _mm_comieq_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareEqualOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareEqualOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomieq_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareEqualUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128 _mm_cmpeq_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareEqualScalar(Vector128<float> left, Vector128<float> right) => CompareEqualScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmpgt_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right) => CompareGreaterThan(left, right);
 
         /// <summary>
+        /// int _mm_comigt_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareGreaterThanOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomigt_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareGreaterThanUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128 _mm_cmpgt_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareGreaterThanScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmpge_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqual(left, right);
 
         /// <summary>
+        /// int _mm_comige_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqualOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomige_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqualUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128 _mm_cmpge_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqualScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmplt_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareLessThan(Vector128<float> left, Vector128<float> right) => CompareLessThan(left, right);
 
         /// <summary>
+        /// int _mm_comilt_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareLessThanOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomilt_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareLessThanUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128 _mm_cmplt_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareLessThanScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmple_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqual(left, right);
 
         /// <summary>
+        /// int _mm_comile_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareLessThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqualOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomile_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqualUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128 _mm_cmple_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqualScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmpneq_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareNotEqual(Vector128<float> left, Vector128<float> right) => CompareNotEqual(left, right);
 
         /// <summary>
+        /// int _mm_comineq_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareNotEqualOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareNotEqualOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomineq_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static bool CompareNotEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareNotEqualUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128 _mm_cmpneq_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareNotEqualScalar(Vector128<float> left, Vector128<float> right) => CompareNotEqualScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmpngt_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareNotGreaterThan(Vector128<float> left, Vector128<float> right) => CompareNotGreaterThan(left, right);
 
         /// <summary>
+        /// __m128 _mm_cmpngt_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareNotGreaterThanScalar(Vector128<float> left, Vector128<float> right) => CompareNotGreaterThanScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmpnge_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareNotGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareNotGreaterThanOrEqual(left, right);
 
         /// <summary>
+        /// __m128 _mm_cmpnge_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareNotGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) => CompareNotGreaterThanOrEqualScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmpnlt_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareNotLessThan(Vector128<float> left, Vector128<float> right) => CompareNotLessThan(left, right);
 
         /// <summary>
+        /// __m128 _mm_cmpnlt_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareNotLessThanScalar(Vector128<float> left, Vector128<float> right) => CompareNotLessThanScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmpnle_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareNotLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareNotLessThanOrEqual(left, right);
 
         /// <summary>
+        /// __m128 _mm_cmpnle_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareNotLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) => CompareNotLessThanOrEqualScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmpord_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareOrdered(Vector128<float> left, Vector128<float> right) => CompareOrdered(left, right);
 
         /// <summary>
+        /// __m128 _mm_cmpord_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareOrderedScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_cmpunord_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> CompareUnordered(Vector128<float> left, Vector128<float> right) => CompareUnordered(left, right);
-        
+
+        /// <summary>
+        /// __m128 _mm_cmpunord_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> CompareUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareUnorderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_cvtss_si32 (__m128 a)
+        /// </summary>
+        public static int ConvertToInt32(Vector128<float> value) => ConvertToInt32(value);
+        /// <summary>
+        /// __int64 _mm_cvtss_si64 (__m128 a)
+        /// </summary>
+        public static long ConvertToInt64(Vector128<float> value) => ConvertToInt64(value);
+        /// <summary>
+        /// float _mm_cvtss_f32 (__m128 a)
+        /// </summary>
+        public static float ConvertToSingle(Vector128<float> value) => ConvertToSingle(value);
+
+        /// <summary>
+        /// __m128 _mm_cvtsi32_ss (__m128 a, int b)
+        /// </summary>
+        public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, int value) => ConvertToVector128SingleScalar(upper, value);
+        /// <summary>
+        /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b)
+        /// </summary>
+        public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, long value) => ConvertToVector128SingleScalar(upper, value);
+
+        /// <summary>
+        /// int _mm_cvttss_si32 (__m128 a)
+        /// </summary>
+        public static int ConvertToInt32WithTruncation(Vector128<float> value) => ConvertToInt32WithTruncation(value);
+        /// <summary>
+        /// __int64 _mm_cvttss_si64 (__m128 a)
+        /// </summary>
+        public static long ConvertToInt64WithTruncation(Vector128<float> value) => ConvertToInt64WithTruncation(value);
+
         /// <summary>
         /// __m128 _mm_div_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right) => Divide(left, right);
 
         /// <summary>
+        /// __m128 _mm_div_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> DivideScalar(Vector128<float> left, Vector128<float> right) => DivideScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_loadu_ps (float const* mem_address)
         /// </summary>
         public static unsafe Vector128<float> Load(float* address) => Load(address);
 
         /// <summary>
+        /// __m128 _mm_load_ss (float const* mem_address)
+        /// </summary>
+        public static unsafe Vector128<float> LoadScalar(float* address) => LoadScalar(address);
+
+        /// <summary>
         /// __m128 _mm_load_ps (float const* mem_address)
         /// </summary>
         public static unsafe Vector128<float> LoadAligned(float* address) => LoadAligned(address);
@@ -111,11 +277,26 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> Max(Vector128<float> left, Vector128<float> right) => Max(left, right);
 
         /// <summary>
+        /// __m128 _mm_max_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> MaxScalar(Vector128<float> left, Vector128<float> right) => MaxScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_min_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> Min(Vector128<float> left, Vector128<float> right) => Min(left, right);
 
         /// <summary>
+        /// __m128 _mm_min_ss (__m128 a,  __m128 b)
+        /// </summary>
+        public static Vector128<float> MinScalar(Vector128<float> left, Vector128<float> right) => MinScalar(left, right);
+
+        /// <summary>
+        /// __m128 _mm_move_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static Vector128<float> MoveScalar(Vector128<float> upper, Vector128<float> value) => MoveScalar(upper, value);
+
+        /// <summary>
         /// __m128 _mm_movehl_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> MoveHighToLow(Vector128<float> left, Vector128<float> right) => MoveHighToLow(left, right);
@@ -131,6 +312,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right) => Multiply(left, right);
 
         /// <summary>
+        /// __m128 _mm_mul_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static Vector128<float> MultiplyScalar(Vector128<float> left, Vector128<float> right) => MultiplyScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_or_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> Or(Vector128<float> left, Vector128<float> right) => Or(left, right);
@@ -141,16 +327,31 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> Reciprocal(Vector128<float> value) => Reciprocal(value);
 
         /// <summary>
+        /// __m128 _mm_rcp_ss (__m128 a)
+        /// </summary>
+        public static Vector128<float> ReciprocalScalar(Vector128<float> value) => ReciprocalScalar(value);
+
+        /// <summary>
         /// __m128 _mm_rsqrt_ps (__m128 a)
         /// </summary>
         public static Vector128<float> ReciprocalSquareRoot(Vector128<float> value) => ReciprocalSquareRoot(value);
 
         /// <summary>
+        /// __m128 _mm_rsqrt_ss (__m128 a)
+        /// </summary>
+        public static Vector128<float> ReciprocalSqrtScalar(Vector128<float> value) => ReciprocalSqrtScalar(value);
+
+        /// <summary>
         /// __m128 _mm_set_ps (float e3, float e2, float e1, float e0)
         /// </summary>
         public static Vector128<float> Set(float e3, float e2, float e1, float e0) => Set(e3, e2, e1, e0);
 
         /// <summary>
+        /// __m128 _mm_set_ss (float a)
+        /// </summary>
+        public static Vector128<float> SetScalar(float value) => SetScalar(value);
+
+        /// <summary>
         /// __m128 _mm_set1_ps (float a)
         /// </summary>
         public static Vector128<float> Set1(float value) => Set1(value);
@@ -186,6 +387,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<float> Sqrt(Vector128<float> value) => Sqrt(value);
 
         /// <summary>
+        /// __m128 _mm_sqrt_ss (__m128 a)
+        /// </summary>
+        public static Vector128<float> SqrtScalar(Vector128<float> value) => SqrtScalar(value);
+
+        /// <summary>
         /// void _mm_store_ps (float* mem_addr, __m128 a)
         /// </summary>
         public static unsafe void StoreAligned(float* address, Vector128<float> source) => StoreAligned(address, source);
@@ -201,11 +407,21 @@ namespace System.Runtime.Intrinsics.X86
         public static unsafe void Store(float* address, Vector128<float> source) => Store(address, source);
 
         /// <summary>
+        /// void _mm_store_ss (float* mem_addr, __m128 a)
+        /// </summary>
+        public static unsafe void StoreScalar(float* address, Vector128<float> source) => StoreScalar(address, source);
+
+        /// <summary>
         /// __m128d _mm_sub_ps (__m128d a, __m128d b)
         /// </summary>
         public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right) => Subtract(left, right);
 
         /// <summary>
+        /// __m128 _mm_sub_ss (__m128 a, __m128 b)
+        /// </summary>
+        public static Vector128<float> SubtractScalar(Vector128<float> left, Vector128<float> right) => SubtractScalar(left, right);
+
+        /// <summary>
         /// __m128 _mm_unpackhi_ps (__m128 a,  __m128 b)
         /// </summary>
         public static Vector128<float> UnpackHigh(Vector128<float> left, Vector128<float> right) => UnpackHigh(left, right);
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs
index 7810f6b85e..8ca8a7f1ba 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs
@@ -53,6 +53,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Add(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_add_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> AddScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_adds_epi8 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
@@ -182,6 +187,21 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> CompareEqual(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comieq_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomieq_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128d _mm_cmpeq_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_cmpgt_epi8 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
@@ -199,11 +219,41 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> CompareGreaterThan(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comigt_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareGreaterThanOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomigt_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareGreaterThanUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128d _mm_cmpgt_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareGreaterThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_cmpge_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comige_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomige_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128d _mm_cmpge_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_cmplt_epi8 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
@@ -221,46 +271,121 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> CompareLessThan(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comilt_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareLessThanOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomilt_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareLessThanUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128d _mm_cmplt_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareLessThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_cmple_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comile_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareLessThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomile_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128d _mm_cmple_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_cmpneq_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareNotEqual(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_comineq_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareNotEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int _mm_ucomineq_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareNotEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128d _mm_cmpneq_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareNotEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_cmpngt_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareNotGreaterThan(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_cmpngt_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareNotGreaterThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_cmpnge_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_cmpnge_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareNotGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_cmpnlt_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareNotLessThan(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_cmpnlt_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareNotLessThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_cmpnle_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_cmpnle_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareNotLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_cmpord_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareOrdered(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_cmpord_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_cmpunord_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareUnordered(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_cmpunord_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_cvtps_epi32 (__m128 a)
         /// </summary>
         public static Vector128<int> ConvertToInt(Vector128<float> value) { throw new PlatformNotSupportedException(); }
@@ -286,6 +411,68 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> ConvertToDouble(Vector128<float> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// double _mm_cvtsd_f64(__m128d a)
+        /// </summary>
+        public static double ConvertToDouble(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// int _mm_cvtsd_si32 (__m128d a)
+        /// </summary>
+        public static int ConvertToInt32(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// int _mm_cvtsi128_si32 (__m128i a)
+        /// </summary>
+        public static int ConvertToInt32(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __int64 _mm_cvtsd_si64 (__m128d a)
+        /// </summary>
+        public static long ConvertToInt64(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __int64 _mm_cvtsi128_si64 (__m128i a)
+        /// </summary>
+        public static long ConvertToInt64(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// int _mm_cvtsi128_si32 (__m128i a)
+        /// </summary>
+        public static uint ConvertToUInt32(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __int64 _mm_cvtsi128_si64 (__m128i a)
+        /// </summary>
+        public static ulong ConvertToUInt64(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128d _mm_cvtsi32_sd (__m128d a, int b)
+        /// </summary>
+        public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, int value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128d _mm_cvtsi64_sd (__m128d a, int b)
+        /// </summary>
+        public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, long value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128d _mm_cvtss_sd (__m128d a, __m128 b)
+        /// </summary>
+        public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128i _mm_cvtsi32_si128 (int a)
+        /// </summary>
+        public static Vector128<int> ConvertToVector128Int32Scalar(int value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128i _mm_cvtsi64_si128 (__int64 a)
+        /// </summary>
+        public static Vector128<long> ConvertToVector128Int64Scalar(long value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128 _mm_cvtsd_ss (__m128 a, __m128d b)
+        /// </summary>
+        public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128i _mm_cvtsi32_si128 (int a)
+        /// </summary>
+        public static Vector128<uint> ConvertToVector128UInt32Scalar(uint value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128i _mm_cvtsi64_si128 (__int64 a)
+        /// </summary>
+        public static Vector128<ulong> ConvertToVector128UInt64Scalar(ulong value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_cvttps_epi32 (__m128 a)
         /// </summary>
         public static Vector128<int> ConvertToIntWithTruncation(Vector128<float> value) { throw new PlatformNotSupportedException(); }
@@ -295,11 +482,25 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<int> ConvertToIntWithTruncation(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// int _mm_cvttsd_si32 (__m128d a)
+        /// </summary>
+        public static int ConvertToInt32WithTruncation(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __int64 _mm_cvttsd_si64 (__m128d a)
+        /// </summary>
+        public static long ConvertToInt64WithTruncation(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128d _mm_div_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> Divide(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_div_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> DivideScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// int _mm_extract_epi16 (__m128i a,  int immediate)
         /// </summary>
         public static short ExtractShort<T>(Vector128<T> value,  byte index) where T : struct { throw new PlatformNotSupportedException(); }
@@ -355,6 +556,11 @@ namespace System.Runtime.Intrinsics.X86
         public static unsafe Vector128<double> Load(double* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_load_sd (double const* mem_address)
+        /// </summary>
+        public static unsafe Vector128<double> LoadScalar(double* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_load_si128 (__m128i const* mem_address)
         /// </summary>
         public static unsafe Vector128<sbyte> LoadAligned(sbyte* address) { throw new PlatformNotSupportedException(); }
@@ -414,6 +620,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Max(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_max_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> MaxScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_min_epu8 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<byte> Min(Vector128<byte> left,  Vector128<byte> right) { throw new PlatformNotSupportedException(); }
@@ -427,6 +638,16 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Min(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_min_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> MinScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// __m128d _mm_move_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static Vector128<double> MoveScalar(Vector128<double> upper, Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// int _mm_movemask_epi8 (__m128i a)
         /// </summary>
         public static int MoveMask(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
@@ -445,6 +666,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Multiply(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_mul_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> MultiplyScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_mulhi_epi16 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<short> MultiplyHi(Vector128<short> left,  Vector128<short> right) { throw new PlatformNotSupportedException(); }
@@ -550,7 +776,12 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128d _mm_set_pd (double e1, double e0)
         /// </summary>
         public static Vector128<double> Set(double e1, double e0) { throw new PlatformNotSupportedException(); }
-        
+
+        /// <summary>
+        /// __m128d _mm_set_sd (double a)
+        /// </summary>
+        public static Vector128<double> SetScalar(double value) { throw new PlatformNotSupportedException(); }
+
         /// <summary>
         /// __m128i _mm_set1_epi8 (char a)
         /// </summary>
@@ -761,6 +992,16 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Sqrt(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_sqrt_sd (__m128d a)
+        /// </summary>
+        public static Vector128<double> SqrtScalar(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void _mm_store_sd (double* mem_addr, __m128d a)
+        /// </summary>
+        public static unsafe void StoreScalar(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
         /// </summary>
         public static unsafe void StoreAligned(sbyte* address, Vector128<sbyte> source) { throw new PlatformNotSupportedException(); }
@@ -927,6 +1168,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Subtract(Vector128<double> left,  Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_sub_ss (__m128d a, __m128d b)
+        /// </summary>
+        public static Vector128<double> SubtractScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_subs_epi8 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.cs
index a586a354d1..dbf2435382 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse2.cs
@@ -53,6 +53,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Add(Vector128<double> left, Vector128<double> right) => Add(left, right);
 
         /// <summary>
+        /// __m128d _mm_add_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> AddScalar(Vector128<double> left, Vector128<double> right) => AddScalar(left, right);
+
+        /// <summary>
         /// __m128i _mm_adds_epi8 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) => AddSaturate(left, right);
@@ -182,6 +187,21 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right) => CompareEqual(left, right);
 
         /// <summary>
+        /// int _mm_comieq_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareEqualOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareEqualOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomieq_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareEqualUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128d _mm_cmpeq_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareEqualScalar(Vector128<double> left, Vector128<double> right) => CompareEqualScalar(left, right);
+
+        /// <summary>
         /// __m128i _mm_cmpgt_epi8 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right) => CompareGreaterThan(left, right);
@@ -199,11 +219,41 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right) => CompareGreaterThan(left, right);
 
         /// <summary>
+        /// int _mm_comigt_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareGreaterThanOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomigt_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareGreaterThanUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128d _mm_cmpgt_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareGreaterThanScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanScalar(left, right);
+
+        /// <summary>
         /// __m128d _mm_cmpge_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqual(left, right);
 
         /// <summary>
+        /// int _mm_comige_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqualOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomige_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqualUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128d _mm_cmpge_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqualScalar(left, right);
+
+        /// <summary>
         /// __m128i _mm_cmplt_epi8 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right) => CompareLessThan(left, right);
@@ -221,46 +271,121 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right) => CompareLessThan(left, right);
 
         /// <summary>
+        /// int _mm_comilt_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareLessThanOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomilt_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareLessThanUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128d _mm_cmplt_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareLessThanScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanScalar(left, right);
+
+        /// <summary>
         /// __m128d _mm_cmple_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqual(left, right);
 
         /// <summary>
+        /// int _mm_comile_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareLessThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqualOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomile_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqualUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128d _mm_cmple_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqualScalar(left, right);
+
+        /// <summary>
         /// __m128d _mm_cmpneq_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareNotEqual(Vector128<double> left, Vector128<double> right) => CompareNotEqual(left, right);
 
         /// <summary>
+        /// int _mm_comineq_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareNotEqualOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareNotEqualOrderedScalar(left, right);
+
+        /// <summary>
+        /// int _mm_ucomineq_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static bool CompareNotEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareNotEqualUnorderedScalar(left, right);
+
+        /// <summary>
+        /// __m128d _mm_cmpneq_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareNotEqualScalar(Vector128<double> left, Vector128<double> right) => CompareNotEqualScalar(left, right);
+
+        /// <summary>
         /// __m128d _mm_cmpngt_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareNotGreaterThan(Vector128<double> left, Vector128<double> right) => CompareNotGreaterThan(left, right);
 
         /// <summary>
+        /// __m128d _mm_cmpngt_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareNotGreaterThanScalar(Vector128<double> left, Vector128<double> right) => CompareNotGreaterThanScalar(left, right);
+
+        /// <summary>
         /// __m128d _mm_cmpnge_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareNotGreaterThanOrEqual(left, right);
 
         /// <summary>
+        /// __m128d _mm_cmpnge_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareNotGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) => CompareNotGreaterThanOrEqualScalar(left, right);
+
+        /// <summary>
         /// __m128d _mm_cmpnlt_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareNotLessThan(Vector128<double> left, Vector128<double> right) => CompareNotLessThan(left, right);
 
         /// <summary>
+        /// __m128d _mm_cmpnlt_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareNotLessThanScalar(Vector128<double> left, Vector128<double> right) => CompareNotLessThanScalar(left, right);
+
+        /// <summary>
         /// __m128d _mm_cmpnle_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareNotLessThanOrEqual(left, right);
 
         /// <summary>
+        /// __m128d _mm_cmpnle_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareNotLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) => CompareNotLessThanOrEqualScalar(left, right);
+
+        /// <summary>
         /// __m128d _mm_cmpord_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareOrdered(Vector128<double> left, Vector128<double> right) => CompareOrdered(left, right);
 
         /// <summary>
+        /// __m128d _mm_cmpord_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareOrderedScalar(left, right);
+
+        /// <summary>
         /// __m128d _mm_cmpunord_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> CompareUnordered(Vector128<double> left, Vector128<double> right) => CompareUnordered(left, right);
 
         /// <summary>
+        /// __m128d _mm_cmpunord_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> CompareUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareUnorderedScalar(left, right);
+
+        /// <summary>
         /// __m128i _mm_cvtps_epi32 (__m128 a)
         /// </summary>
         public static Vector128<int> ConvertToInt(Vector128<float> value) => ConvertToInt(value);
@@ -285,6 +410,69 @@ namespace System.Runtime.Intrinsics.X86
         /// </summary>
         public static Vector128<double> ConvertToDouble(Vector128<float> value) => ConvertToDouble(value);
 
+        
+        /// <summary>
+        /// double _mm_cvtsd_f64(__m128d a)
+        /// </summary>
+        public static double ConvertToDouble(Vector128<double> value) => ConvertToDouble(value);
+        /// <summary>
+        /// int _mm_cvtsd_si32 (__m128d a)
+        /// </summary>
+        public static int ConvertToInt32(Vector128<double> value) => ConvertToInt32(value);
+        /// <summary>
+        /// int _mm_cvtsi128_si32 (__m128i a)
+        /// </summary>
+        public static int ConvertToInt32(Vector128<int> value) => ConvertToInt32(value);
+        /// <summary>
+        /// __int64 _mm_cvtsd_si64 (__m128d a)
+        /// </summary>
+        public static long ConvertToInt64(Vector128<double> value) => ConvertToInt64(value);
+        /// <summary>
+        /// __int64 _mm_cvtsi128_si64 (__m128i a)
+        /// </summary>
+        public static long ConvertToInt64(Vector128<long> value) => ConvertToInt64(value);
+        /// <summary>
+        /// int _mm_cvtsi128_si32 (__m128i a)
+        /// </summary>
+        public static uint ConvertToUInt32(Vector128<uint> value) => ConvertToUInt32(value);
+        /// <summary>
+        /// __int64 _mm_cvtsi128_si64 (__m128i a)
+        /// </summary>
+        public static ulong ConvertToUInt64(Vector128<ulong> value) => ConvertToUInt64(value);
+
+        /// <summary>
+        /// __m128d _mm_cvtsi32_sd (__m128d a, int b)
+        /// </summary>
+        public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, int value) => ConvertToVector128DoubleScalar(upper, value);
+        /// <summary>
+        /// __m128d _mm_cvtsi64_sd (__m128d a, int b)
+        /// </summary>
+        public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, long value) => ConvertToVector128DoubleScalar(upper, value);
+        /// <summary>
+        /// __m128d _mm_cvtss_sd (__m128d a, __m128 b)
+        /// </summary>
+        public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, Vector128<float> value) => ConvertToVector128DoubleScalar(upper, value);
+        /// <summary>
+        /// __m128i _mm_cvtsi32_si128 (int a)
+        /// </summary>
+        public static Vector128<int> ConvertToVector128Int32Scalar(int value) => ConvertToVector128Int32Scalar(value);
+        /// <summary>
+        /// __m128i _mm_cvtsi64_si128 (__int64 a)
+        /// </summary>
+        public static Vector128<long> ConvertToVector128Int64Scalar(long value) => ConvertToVector128Int64Scalar(value);
+        /// <summary>
+        /// __m128 _mm_cvtsd_ss (__m128 a, __m128d b)
+        /// </summary>
+        public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, Vector128<double> value) => ConvertToVector128SingleScalar(upper, value);
+        /// <summary>
+        /// __m128i _mm_cvtsi32_si128 (int a)
+        /// </summary>
+        public static Vector128<uint> ConvertToVector128UInt32Scalar(uint value) => ConvertToVector128UInt32Scalar(value);
+        /// <summary>
+        /// __m128i _mm_cvtsi64_si128 (__int64 a)
+        /// </summary>
+        public static Vector128<ulong> ConvertToVector128UInt64Scalar(ulong value) => ConvertToVector128UInt64Scalar(value);
+
         /// <summary>
         /// __m128i _mm_cvttps_epi32 (__m128 a)
         /// </summary>
@@ -295,11 +483,25 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<int> ConvertToIntWithTruncation(Vector128<double> value) => ConvertToIntWithTruncation(value);
 
         /// <summary>
+        /// int _mm_cvttsd_si32 (__m128d a)
+        /// </summary>
+        public static int ConvertToInt32WithTruncation(Vector128<double> value) => ConvertToInt32WithTruncation(value);
+        /// <summary>
+        /// __int64 _mm_cvttsd_si64 (__m128d a)
+        /// </summary>
+        public static long ConvertToInt64WithTruncation(Vector128<double> value) => ConvertToInt64WithTruncation(value);
+
+        /// <summary>
         /// __m128d _mm_div_pd (__m128d a,  __m128d b)
         /// </summary>
         public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) => Divide(left, right);
 
         /// <summary>
+        /// __m128d _mm_div_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> DivideScalar(Vector128<double> left, Vector128<double> right) => DivideScalar(left, right);
+
+        /// <summary>
         /// int _mm_extract_epi16 (__m128i a,  int immediate)
         /// </summary>
         public static short ExtractShort<T>(Vector128<T> value, byte index) where T : struct
@@ -371,6 +573,11 @@ namespace System.Runtime.Intrinsics.X86
         public static unsafe Vector128<double> Load(double* address) => Load(address);
 
         /// <summary>
+        /// __m128d _mm_load_sd (double const* mem_address)
+        /// </summary>
+        public static unsafe Vector128<double> LoadScalar(double* address) => LoadScalar(address);
+
+        /// <summary>
         /// __m128i _mm_load_si128 (__m128i const* mem_address)
         /// </summary>
         public static unsafe Vector128<sbyte> LoadAligned(sbyte* address) => LoadAligned(address);
@@ -430,6 +637,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Max(Vector128<double> left, Vector128<double> right) => Max(left, right);
 
         /// <summary>
+        /// __m128d _mm_max_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> MaxScalar(Vector128<double> left, Vector128<double> right) => MaxScalar(left, right);
+
+        /// <summary>
         /// __m128i _mm_min_epu8 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right) => Min(left, right);
@@ -443,6 +655,16 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Min(Vector128<double> left, Vector128<double> right) => Min(left, right);
 
         /// <summary>
+        /// __m128d _mm_min_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> MinScalar(Vector128<double> left, Vector128<double> right) => MinScalar(left, right);
+
+        /// <summary>
+        /// __m128d _mm_move_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static Vector128<double> MoveScalar(Vector128<double> upper, Vector128<double> value) => MoveScalar(upper, value);
+
+        /// <summary>
         /// int _mm_movemask_epi8 (__m128i a)
         /// </summary>
         public static int MoveMask(Vector128<sbyte> value) => MoveMask(value);
@@ -461,6 +683,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) => Multiply(left, right);
 
         /// <summary>
+        /// __m128d _mm_mul_sd (__m128d a,  __m128d b)
+        /// </summary>
+        public static Vector128<double> MultiplyScalar(Vector128<double> left, Vector128<double> right) => MultiplyScalar(left, right);
+
+        /// <summary>
         /// __m128i _mm_mulhi_epi16 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<short> MultiplyHi(Vector128<short> left, Vector128<short> right) => MultiplyHi(left, right);
@@ -566,7 +793,12 @@ namespace System.Runtime.Intrinsics.X86
         /// __m128d _mm_set_pd (double e1, double e0)
         /// </summary>
         public static Vector128<double> Set(double e1, double e0) => Set(e1, e0);
-        
+
+        /// <summary>
+        /// __m128d _mm_set_sd (double a)
+        /// </summary>
+        public static Vector128<double> SetScalar(double value) => SetScalar(value);
+
         /// <summary>
         /// __m128i _mm_set1_epi8 (char a)
         /// </summary>
@@ -781,6 +1013,16 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Sqrt(Vector128<double> value) => Sqrt(value);
 
         /// <summary>
+        /// __m128d _mm_sqrt_sd (__m128d a)
+        /// </summary>
+        public static Vector128<double> SqrtScalar(Vector128<double> value) => SqrtScalar(value);
+
+        /// <summary>
+        /// void _mm_store_sd (double* mem_addr, __m128d a)
+        /// </summary>
+        public static unsafe void StoreScalar(double* address, Vector128<double> source) => StoreScalar(address, source);
+
+        /// <summary>
         /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
         /// </summary>
         public static unsafe void StoreAligned(sbyte* address, Vector128<sbyte> source) => StoreAligned(address, source);
@@ -947,6 +1189,11 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right) => Subtract(left, right);
 
         /// <summary>
+        /// __m128d _mm_sub_sd (__m128d a, __m128d b)
+        /// </summary>
+        public static Vector128<double> SubtractScalar(Vector128<double> left, Vector128<double> right) => SubtractScalar(left, right);
+
+        /// <summary>
         /// __m128i _mm_subs_epi8 (__m128i a,  __m128i b)
         /// </summary>
         public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right) => SubtractSaturate(left, right);
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs
index 3ca756b95f..a4bd188078 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs
@@ -62,6 +62,15 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Ceiling(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_ceil_sd (__m128d a)
+        /// </summary>
+        public static Vector128<double> CeilingScalar(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128 _mm_ceil_ss (__m128 a)
+        /// </summary>
+        public static Vector128<float> CeilingScalar(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b)
         /// </summary>
         public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
@@ -172,6 +181,15 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Floor(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// __m128d _mm_floor_sd (__m128d a)
+        /// </summary>
+        public static Vector128<double> FloorScalar(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128 _mm_floor_ss (__m128 a)
+        /// </summary>
+        public static Vector128<float> FloorScalar(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
         /// </summary>
         public static Vector128<T> InsertSbyte<T>(Vector128<T> value, sbyte data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
@@ -310,6 +328,50 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> RoundCurrentDirection(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
+        /// _MM_FROUND_CUR_DIRECTION
+        /// </summary>
+        public static Vector128<double> RoundCurrentDirectionScalar(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128d _mm_round_sd (__m128d a, int rounding)
+        /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<double> RoundToNearestIntegerScalar(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<double> RoundToNegativeInfinityScalar(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<double> RoundToPositiveInfinityScalar(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<double> RoundToZeroScalar(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// _MM_FROUND_CUR_DIRECTION
+        /// </summary>
+        public static Vector128<float> RoundCurrentDirectionScalar(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// __m128 _mm_round_ss (__m128 a, int rounding)
+        /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<float> RoundToNearestIntegerScalar(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<float> RoundToNegativeInfinityScalar(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<float> RoundToPositiveInfinityScalar(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<float> RoundToZeroScalar(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
         /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
         /// </summary>
         public static unsafe Vector128<sbyte> LoadAlignedNonTemporal(sbyte* address) { throw new PlatformNotSupportedException(); }
diff --git a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.cs b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.cs
index 675a75023c..094041bd75 100644
--- a/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.cs
+++ b/src/mscorlib/src/System/Runtime/Intrinsics/X86/Sse41.cs
@@ -62,6 +62,15 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Ceiling(Vector128<double> value) => Ceiling(value);
 
         /// <summary>
+        /// __m128d _mm_ceil_sd (__m128d a)
+        /// </summary>
+        public static Vector128<double> CeilingScalar(Vector128<double> value) => CeilingScalar(value);
+        /// <summary>
+        /// __m128 _mm_ceil_ss (__m128 a)
+        /// </summary>
+        public static Vector128<float> CeilingScalar(Vector128<float> value) => CeilingScalar(value);
+
+        /// <summary>
         /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b)
         /// </summary>
         public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right) => CompareEqual(left, right);
@@ -200,6 +209,15 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> Floor(Vector128<double> value) => Floor(value);
 
         /// <summary>
+        /// __m128d _mm_floor_sd (__m128d a)
+        /// </summary>
+        public static Vector128<double> FloorScalar(Vector128<double> value) => FloorScalar(value);
+        /// <summary>
+        /// __m128 _mm_floor_ss (__m128 a)
+        /// </summary>
+        public static Vector128<float> FloorScalar(Vector128<float> value) => FloorScalar(value);
+
+        /// <summary>
         /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
         /// </summary>
         public static Vector128<T> InsertSbyte<T>(Vector128<T> value, sbyte data, byte index) where T : struct
@@ -366,6 +384,50 @@ namespace System.Runtime.Intrinsics.X86
         public static Vector128<double> RoundCurrentDirection(Vector128<double> value) => RoundCurrentDirection(value);
 
         /// <summary>
+        /// _MM_FROUND_CUR_DIRECTION
+        /// </summary>
+        public static Vector128<double> RoundCurrentDirectionScalar(Vector128<double> value) => RoundCurrentDirectionScalar(value);
+        /// <summary>
+        /// __m128d _mm_round_sd (__m128d a, int rounding)
+        /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<double> RoundToNearestIntegerScalar(Vector128<double> value) => RoundToNearestIntegerScalar(value);
+        /// <summary>
+        /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<double> RoundToNegativeInfinityScalar(Vector128<double> value) => RoundToNegativeInfinityScalar(value);
+        /// <summary>
+        /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<double> RoundToPositiveInfinityScalar(Vector128<double> value) => RoundToPositiveInfinityScalar(value);
+        /// <summary>
+        /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<double> RoundToZeroScalar(Vector128<double> value) => RoundToZeroScalar(value);
+
+        /// <summary>
+        /// _MM_FROUND_CUR_DIRECTION
+        /// </summary>
+        public static Vector128<float> RoundCurrentDirectionScalar(Vector128<float> value) => RoundCurrentDirectionScalar(value);
+        /// <summary>
+        /// __m128 _mm_round_ss (__m128 a, int rounding)
+        /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<float> RoundToNearestIntegerScalar(Vector128<float> value) => RoundToNearestIntegerScalar(value);
+        /// <summary>
+        /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<float> RoundToNegativeInfinityScalar(Vector128<float> value) => RoundToNegativeInfinityScalar(value);
+        /// <summary>
+        /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<float> RoundToPositiveInfinityScalar(Vector128<float> value) => RoundToPositiveInfinityScalar(value);
+        /// <summary>
+        /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
+        /// </summary>
+        public static Vector128<float> RoundToZeroScalar(Vector128<float> value) => RoundToZeroScalar(value);
+
+        /// <summary>
         /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
         /// </summary>
         public static unsafe Vector128<sbyte> LoadAlignedNonTemporal(sbyte* address) => LoadAlignedNonTemporal(address);