From d565edf5c9993b13d5c1a3591d1ff10257d33713 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Mon, 8 Apr 2024 12:20:38 -0700
Subject: [PATCH 1/4] Expose the ConvertToIntegerNative APIs for the
 floating-point types

---
 .../ref/System.Numerics.Vectors.cs            |  6 ++
 .../src/System/Decimal.cs                     |  8 +++
 .../src/System/Double.cs                      | 10 +++
 .../System.Private.CoreLib/src/System/Half.cs |  8 +++
 .../src/System/Numerics/IFloatingPoint.cs     | 20 ++++++
 .../src/System/Numerics/Vector.cs             | 34 ++++++++--
 .../System/Runtime/InteropServices/NFloat.cs  |  8 +++
 .../System/Runtime/Intrinsics/Vector128.cs    | 62 +++++++++++++++++--
 .../System/Runtime/Intrinsics/Vector256.cs    | 62 +++++++++++++++++--
 .../System/Runtime/Intrinsics/Vector512.cs    | 62 +++++++++++++++++--
 .../src/System/Runtime/Intrinsics/Vector64.cs | 38 ++++++++++--
 .../src/System/Single.cs                      | 10 +++
 .../ref/System.Runtime.InteropServices.cs     |  2 +
 .../ref/System.Runtime.Intrinsics.cs          | 24 +++++++
 .../System.Runtime/ref/System.Runtime.cs      | 12 ++++
 15 files changed, 346 insertions(+), 20 deletions(-)

diff --git a/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs b/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
index 8bf4cb6c53482..531a379cf06e9 100644
--- a/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
+++ b/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
@@ -235,14 +235,20 @@ public static partial class Vector
         [System.CLSCompliantAttribute(false)]
         public static System.Numerics.Vector<System.Double> ConvertToDouble(System.Numerics.Vector<System.UInt64> value) { throw null; }
         public static System.Numerics.Vector<System.Int32> ConvertToInt32(System.Numerics.Vector<System.Single> value) { throw null; }
+        public static System.Numerics.Vector<System.Int32> ConvertToInt32Native(System.Numerics.Vector<System.Single> value) { throw null; }
         public static System.Numerics.Vector<System.Int64> ConvertToInt64(System.Numerics.Vector<System.Double> value) { throw null; }
+        public static System.Numerics.Vector<System.Int64> ConvertToInt64Native(System.Numerics.Vector<System.Double> value) { throw null; }
         public static System.Numerics.Vector<System.Single> ConvertToSingle(System.Numerics.Vector<System.Int32> value) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static System.Numerics.Vector<System.Single> ConvertToSingle(System.Numerics.Vector<System.UInt32> value) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static System.Numerics.Vector<System.UInt32> ConvertToUInt32(System.Numerics.Vector<System.Single> value) { throw null; }
         [System.CLSCompliantAttribute(false)]
+        public static System.Numerics.Vector<System.UInt32> ConvertToUInt32Native(System.Numerics.Vector<System.Single> value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
         public static System.Numerics.Vector<System.UInt64> ConvertToUInt64(System.Numerics.Vector<System.Double> value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static System.Numerics.Vector<System.UInt64> ConvertToUInt64Native(System.Numerics.Vector<System.Double> value) { throw null; }
         public static System.Numerics.Vector<T> CreateSequence<T>(T start, T step) { throw null; }
         public static System.Numerics.Vector<T> Divide<T>(System.Numerics.Vector<T> left, System.Numerics.Vector<T> right) { throw null; }
         public static System.Numerics.Vector<T> Divide<T>(System.Numerics.Vector<T> left, T right) { throw null; }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Decimal.cs b/src/libraries/System.Private.CoreLib/src/System/Decimal.cs
index f2d89445f834b..189e54dcc1ef7 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Decimal.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Decimal.cs
@@ -1117,6 +1117,14 @@ object IConvertible.ToType(Type type, IFormatProvider? provider)
         // IFloatingPoint
         //
 
+        /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToInteger{TInteger}(TSelf)" />
+        public static TInteger ConvertToInteger<TInteger>(decimal value)
+            where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);
+
+        /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToIntegerNative{TInteger}(TSelf)" />
+        public static TInteger ConvertToIntegerNative<TInteger>(decimal value)
+            where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);
+
         /// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentByteCount()" />
         int IFloatingPoint<decimal>.GetExponentByteCount() => sizeof(sbyte);
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Double.cs b/src/libraries/System.Private.CoreLib/src/System/Double.cs
index 71d73546bc136..04e8269c78f46 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Double.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Double.cs
@@ -655,6 +655,16 @@ public static bool IsPow2(double value)
         [Intrinsic]
         public static double Ceiling(double x) => Math.Ceiling(x);
 
+        /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToInteger{TInteger}(TSelf)" />
+        [Intrinsic]
+        public static TInteger ConvertToInteger<TInteger>(double value)
+            where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);
+
+        /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToIntegerNative{TInteger}(TSelf)" />
+        [Intrinsic]
+        public static TInteger ConvertToIntegerNative<TInteger>(double value)
+            where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);
+
         /// <inheritdoc cref="IFloatingPoint{TSelf}.Floor(TSelf)" />
         [Intrinsic]
         public static double Floor(double x) => Math.Floor(x);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Half.cs b/src/libraries/System.Private.CoreLib/src/System/Half.cs
index adc7df07932f7..d4459c5162366 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Half.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Half.cs
@@ -1314,6 +1314,14 @@ public static bool IsPow2(Half value)
         /// <inheritdoc cref="IFloatingPoint{TSelf}.Ceiling(TSelf)" />
         public static Half Ceiling(Half x) => (Half)MathF.Ceiling((float)x);
 
+        /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToInteger{TInteger}(TSelf)" />
+        public static TInteger ConvertToInteger<TInteger>(Half value)
+            where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);
+
+        /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToIntegerNative{TInteger}(TSelf)" />
+        public static TInteger ConvertToIntegerNative<TInteger>(Half value)
+            where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);
+
         /// <inheritdoc cref="IFloatingPoint{TSelf}.Floor(TSelf)" />
         public static Half Floor(Half x) => (Half)MathF.Floor((float)x);
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/IFloatingPoint.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/IFloatingPoint.cs
index e36c76007bbdf..9c92a14f0e75c 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/IFloatingPoint.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/IFloatingPoint.cs
@@ -16,6 +16,26 @@ public interface IFloatingPoint<TSelf>
         /// <returns>The ceiling of <paramref name="x" />.</returns>
         static virtual TSelf Ceiling(TSelf x) => TSelf.Round(x, digits: 0, MidpointRounding.ToPositiveInfinity);
 
+        /// <summary>Converts a value to a specified integer type using saturation on overflow</summary>
+        /// <typeparam name="TInteger">The integer type to which <paramref name="value" /> is converted.</typeparam>
+        /// <param name="value">The value to be converted.</param>
+        /// <returns>An instance of <typeparamref name="TInteger" /> created from <paramref name="value" />.</returns>
+        static virtual TInteger ConvertToInteger<TInteger>(TSelf value)
+            where TInteger : IBinaryInteger<TInteger>
+        {
+            return TInteger.CreateSaturating(value);
+        }
+
+        /// <summary>Converts a value to a specified integer type using platform specific behavior on overflow.</summary>
+        /// <typeparam name="TInteger">The integer type to which <paramref name="value" /> is converted.</typeparam>
+        /// <param name="value">The value to be converted.</param>
+        /// <returns>An instance of <typeparamref name="TInteger" /> created from <paramref name="value" />.</returns>
+        static virtual TInteger ConvertToIntegerNative<TInteger>(TSelf value)
+            where TInteger : IBinaryInteger<TInteger>
+        {
+            return TSelf.ConvertToInteger<TInteger>(value);
+        }
+
         /// <summary>Computes the floor of a value.</summary>
         /// <param name="x">The value whose floor is to be computed.</param>
         /// <returns>The floor of <paramref name="x" />.</returns>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
index 5d8bc58bbe26e..0e968e6fca8f3 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
@@ -325,7 +325,7 @@ public static Vector<double> ConvertToDouble(Vector<ulong> value)
             }
         }
 
-        /// <summary>Converts a <see cref="Vector{Single}" /> to a <see cref="Vector{Int32}" />.</summary>
+        /// <summary>Converts a <see cref="Vector{Single}" /> to a <see cref="Vector{Int32}" /> using saturation on overflow.</summary>
         /// <param name="value">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -342,7 +342,13 @@ public static Vector<int> ConvertToInt32(Vector<float> value)
             return result;
         }
 
-        /// <summary>Converts a <see cref="Vector{Double}" /> to a <see cref="Vector{Int64}" />.</summary>
+        /// <summary>Converts a <see cref="Vector{Single}" /> to a <see cref="Vector{Int32}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="value">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        public static Vector<int> ConvertToInt32Native(Vector<float> value) => ConvertToInt32(value);
+
+        /// <summary>Converts a <see cref="Vector{Double}" /> to a <see cref="Vector{Int64}" /> using saturation on overflow.</summary>
         /// <param name="value">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -359,6 +365,12 @@ public static Vector<long> ConvertToInt64(Vector<double> value)
             return result;
         }
 
+        /// <summary>Converts a <see cref="Vector{Double}" /> to a <see cref="Vector{Int64}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="value">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        public static Vector<long> ConvertToInt64Native(Vector<double> value) => ConvertToInt64(value);
+
         /// <summary>Converts a <see cref="Vector{Int32}" /> to a <see cref="Vector{Single}" />.</summary>
         /// <param name="value">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
@@ -396,7 +408,7 @@ public static Vector<float> ConvertToSingle(Vector<uint> value)
             }
         }
 
-        /// <summary>Converts a <see cref="Vector{Single}" /> to a <see cref="Vector{UInt32}" />.</summary>
+        /// <summary>Converts a <see cref="Vector{Single}" /> to a <see cref="Vector{UInt32}" /> using saturation on overflow.</summary>
         /// <param name="value">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -414,7 +426,14 @@ public static Vector<uint> ConvertToUInt32(Vector<float> value)
             return result;
         }
 
-        /// <summary>Converts a <see cref="Vector{Double}" /> to a <see cref="Vector{UInt64}" />.</summary>
+        /// <summary>Converts a <see cref="Vector{Single}" /> to a <see cref="Vector{UInt32}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="value">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [CLSCompliant(false)]
+        public static Vector<uint> ConvertToUInt32Native(Vector<float> value) => ConvertToUInt32(value);
+
+        /// <summary>Converts a <see cref="Vector{Double}" /> to a <see cref="Vector{UInt64}" /> using saturation on overflow.</summary>
         /// <param name="value">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -432,6 +451,13 @@ public static Vector<ulong> ConvertToUInt64(Vector<double> value)
             return result;
         }
 
+        /// <summary>Converts a <see cref="Vector{Double}" /> to a <see cref="Vector{UInt64}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="value">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [CLSCompliant(false)]
+        public static Vector<ulong> ConvertToUInt64Native(Vector<double> value) => ConvertToUInt64(value);
+
         /// <summary>Creates a new <see cref="Vector{T}" /> instance where the elements begin at a specified value and which are spaced apart according to another specified value.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="start">The value that element 0 will be initialized to.</param>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NFloat.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NFloat.cs
index 37c39bbc029a2..b314daec02a93 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NFloat.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NFloat.cs
@@ -992,6 +992,14 @@ public int CompareTo(object? obj)
         /// <inheritdoc cref="IFloatingPoint{TSelf}.Ceiling(TSelf)" />
         public static NFloat Ceiling(NFloat x) => new NFloat(NativeType.Ceiling(x._value));
 
+        /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToInteger{TInteger}(TSelf)" />
+        public static TInteger ConvertToInteger<TInteger>(NFloat value)
+            where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);
+
+        /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToIntegerNative{TInteger}(TSelf)" />
+        public static TInteger ConvertToIntegerNative<TInteger>(NFloat value)
+            where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);
+
         /// <inheritdoc cref="IFloatingPoint{TSelf}.Floor(TSelf)" />
         public static NFloat Floor(NFloat x) => new NFloat(NativeType.Floor(x._value));
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
index 66c0a47734429..b85e4e6cdd531 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
@@ -468,7 +468,7 @@ public static unsafe Vector128<double> ConvertToDouble(Vector128<ulong> vector)
             }
         }
 
-        /// <summary>Converts a <see cref="Vector128{Single}" /> to a <see cref="Vector128{Int32}" />.</summary>
+        /// <summary>Converts a <see cref="Vector128{Single}" /> to a <see cref="Vector128{Int32}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -481,7 +481,20 @@ public static unsafe Vector128<int> ConvertToInt32(Vector128<float> vector)
             );
         }
 
-        /// <summary>Converts a <see cref="Vector128{Double}" /> to a <see cref="Vector128{Int64}" />.</summary>
+        /// <summary>Converts a <see cref="Vector128{Single}" /> to a <see cref="Vector128{Int32}" /> platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Vector128<int> ConvertToInt32Native(Vector128<float> vector)
+        {
+            return Create(
+                Vector64.ConvertToInt32Native(vector._lower),
+                Vector64.ConvertToInt32Native(vector._upper)
+            );
+        }
+
+        /// <summary>Converts a <see cref="Vector128{Double}" /> to a <see cref="Vector128{Int64}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -494,6 +507,19 @@ public static unsafe Vector128<long> ConvertToInt64(Vector128<double> vector)
             );
         }
 
+        /// <summary>Converts a <see cref="Vector128{Double}" /> to a <see cref="Vector128{Int64}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Vector128<long> ConvertToInt64Native(Vector128<double> vector)
+        {
+            return Create(
+                Vector64.ConvertToInt64Native(vector._lower),
+                Vector64.ConvertToInt64Native(vector._upper)
+            );
+        }
+
         /// <summary>Converts a <see cref="Vector128{Int32}" /> to a <see cref="Vector128{Single}" />.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
@@ -564,7 +590,7 @@ static Vector128<float> SoftwareFallback(Vector128<uint> vector)
             }
         }
 
-        /// <summary>Converts a <see cref="Vector128{Single}" /> to a <see cref="Vector128{UInt32}" />.</summary>
+        /// <summary>Converts a <see cref="Vector128{Single}" /> to a <see cref="Vector128{UInt32}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -578,7 +604,21 @@ public static unsafe Vector128<uint> ConvertToUInt32(Vector128<float> vector)
             );
         }
 
-        /// <summary>Converts a <see cref="Vector128{Double}" /> to a <see cref="Vector128{UInt64}" />.</summary>
+        /// <summary>Converts a <see cref="Vector128{Single}" /> to a <see cref="Vector128{UInt32}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Vector128<uint> ConvertToUInt32Native(Vector128<float> vector)
+        {
+            return Create(
+                Vector64.ConvertToUInt32Native(vector._lower),
+                Vector64.ConvertToUInt32Native(vector._upper)
+            );
+        }
+
+        /// <summary>Converts a <see cref="Vector128{Double}" /> to a <see cref="Vector128{UInt64}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -592,6 +632,20 @@ public static unsafe Vector128<ulong> ConvertToUInt64(Vector128<double> vector)
             );
         }
 
+        /// <summary>Converts a <see cref="Vector128{Double}" /> to a <see cref="Vector128{UInt64}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Vector128<ulong> ConvertToUInt64Native(Vector128<double> vector)
+        {
+            return Create(
+                Vector64.ConvertToUInt64Native(vector._lower),
+                Vector64.ConvertToUInt64Native(vector._upper)
+            );
+        }
+
         /// <summary>Copies a <see cref="Vector128{T}" /> to a given array.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="vector">The vector to be copied.</param>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
index 1347a082afab9..4d174eef19754 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
@@ -386,7 +386,7 @@ public static Vector256<double> ConvertToDouble(Vector256<ulong> vector)
             }
         }
 
-        /// <summary>Converts a <see cref="Vector256{Single}" /> to a <see cref="Vector256{Int32}" />.</summary>
+        /// <summary>Converts a <see cref="Vector256{Single}" /> to a <see cref="Vector256{Int32}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -399,7 +399,20 @@ public static Vector256<int> ConvertToInt32(Vector256<float> vector)
             );
         }
 
-        /// <summary>Converts a <see cref="Vector256{Double}" /> to a <see cref="Vector256{Int64}" />.</summary>
+        /// <summary>Converts a <see cref="Vector256{Single}" /> to a <see cref="Vector256{Int32}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<int> ConvertToInt32Native(Vector256<float> vector)
+        {
+            return Create(
+                Vector128.ConvertToInt32Native(vector._lower),
+                Vector128.ConvertToInt32Native(vector._upper)
+            );
+        }
+
+        /// <summary>Converts a <see cref="Vector256{Double}" /> to a <see cref="Vector256{Int64}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -412,6 +425,19 @@ public static Vector256<long> ConvertToInt64(Vector256<double> vector)
             );
         }
 
+        /// <summary>Converts a <see cref="Vector256{Double}" /> to a <see cref="Vector256{Int64}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<long> ConvertToInt64Native(Vector256<double> vector)
+        {
+            return Create(
+                Vector128.ConvertToInt64Native(vector._lower),
+                Vector128.ConvertToInt64Native(vector._upper)
+            );
+        }
+
         /// <summary>Converts a <see cref="Vector256{Int32}" /> to a <see cref="Vector256{Single}" />.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
@@ -472,7 +498,7 @@ public static Vector256<float> ConvertToSingle(Vector256<uint> vector)
             }
         }
 
-        /// <summary>Converts a <see cref="Vector256{Single}" /> to a <see cref="Vector256{UInt32}" />.</summary>
+        /// <summary>Converts a <see cref="Vector256{Single}" /> to a <see cref="Vector256{UInt32}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -486,7 +512,21 @@ public static Vector256<uint> ConvertToUInt32(Vector256<float> vector)
             );
         }
 
-        /// <summary>Converts a <see cref="Vector256{Double}" /> to a <see cref="Vector256{UInt64}" />.</summary>
+        /// <summary>Converts a <see cref="Vector256{Single}" /> to a <see cref="Vector256{UInt32}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<uint> ConvertToUInt32Native(Vector256<float> vector)
+        {
+            return Create(
+                Vector128.ConvertToUInt32Native(vector._lower),
+                Vector128.ConvertToUInt32Native(vector._upper)
+            );
+        }
+
+        /// <summary>Converts a <see cref="Vector256{Double}" /> to a <see cref="Vector256{UInt64}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -500,6 +540,20 @@ public static Vector256<ulong> ConvertToUInt64(Vector256<double> vector)
             );
         }
 
+        /// <summary>Converts a <see cref="Vector256{Double}" /> to a <see cref="Vector256{UInt64}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<ulong> ConvertToUInt64Native(Vector256<double> vector)
+        {
+            return Create(
+                Vector128.ConvertToUInt64Native(vector._lower),
+                Vector128.ConvertToUInt64Native(vector._upper)
+            );
+        }
+
         /// <summary>Copies a <see cref="Vector256{T}" /> to a given array.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="vector">The vector to be copied.</param>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs
index edb84585a987d..d63f12afb64d9 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs
@@ -348,7 +348,7 @@ public static Vector512<double> ConvertToDouble(Vector512<ulong> vector)
             );
         }
 
-        /// <summary>Converts a <see cref="Vector512{Single}" /> to a <see cref="Vector512{Int32}" />.</summary>
+        /// <summary>Converts a <see cref="Vector512{Single}" /> to a <see cref="Vector512{Int32}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -361,7 +361,20 @@ public static Vector512<int> ConvertToInt32(Vector512<float> vector)
             );
         }
 
-        /// <summary>Converts a <see cref="Vector512{Double}" /> to a <see cref="Vector512{Int64}" />.</summary>
+        /// <summary>Converts a <see cref="Vector512{Single}" /> to a <see cref="Vector512{Int32}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<int> ConvertToInt32Native(Vector512<float> vector)
+        {
+            return Create(
+                Vector256.ConvertToInt32Native(vector._lower),
+                Vector256.ConvertToInt32Native(vector._upper)
+            );
+        }
+
+        /// <summary>Converts a <see cref="Vector512{Double}" /> to a <see cref="Vector512{Int64}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -374,6 +387,19 @@ public static Vector512<long> ConvertToInt64(Vector512<double> vector)
             );
         }
 
+        /// <summary>Converts a <see cref="Vector512{Double}" /> to a <see cref="Vector512{Int64}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<long> ConvertToInt64Native(Vector512<double> vector)
+        {
+            return Create(
+                Vector256.ConvertToInt64Native(vector._lower),
+                Vector256.ConvertToInt64Native(vector._upper)
+            );
+        }
+
         /// <summary>Converts a <see cref="Vector512{Int32}" /> to a <see cref="Vector512{Single}" />.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
@@ -401,7 +427,7 @@ public static Vector512<float> ConvertToSingle(Vector512<uint> vector)
             );
         }
 
-        /// <summary>Converts a <see cref="Vector512{Single}" /> to a <see cref="Vector512{UInt32}" />.</summary>
+        /// <summary>Converts a <see cref="Vector512{Single}" /> to a <see cref="Vector512{UInt32}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -415,7 +441,21 @@ public static Vector512<uint> ConvertToUInt32(Vector512<float> vector)
             );
         }
 
-        /// <summary>Converts a <see cref="Vector512{Double}" /> to a <see cref="Vector512{UInt64}" />.</summary>
+        /// <summary>Converts a <see cref="Vector512{Single}" /> to a <see cref="Vector512{UInt32}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<uint> ConvertToUInt32Native(Vector512<float> vector)
+        {
+            return Create(
+                Vector256.ConvertToUInt32Native(vector._lower),
+                Vector256.ConvertToUInt32Native(vector._upper)
+            );
+        }
+
+        /// <summary>Converts a <see cref="Vector512{Double}" /> to a <see cref="Vector512{UInt64}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -429,6 +469,20 @@ public static Vector512<ulong> ConvertToUInt64(Vector512<double> vector)
             );
         }
 
+        /// <summary>Converts a <see cref="Vector512{Double}" /> to a <see cref="Vector512{UInt64}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<ulong> ConvertToUInt64Native(Vector512<double> vector)
+        {
+            return Create(
+                Vector256.ConvertToUInt64Native(vector._lower),
+                Vector256.ConvertToUInt64Native(vector._upper)
+            );
+        }
+
         /// <summary>Copies a <see cref="Vector512{T}" /> to a given array.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="vector">The vector to be copied.</param>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs
index 50e9f697c94f4..04c5e0672a9d1 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs
@@ -339,7 +339,7 @@ public static unsafe Vector64<double> ConvertToDouble(Vector64<ulong> vector)
             return result;
         }
 
-        /// <summary>Converts a <see cref="Vector64{Single}" /> to a <see cref="Vector64{Int32}" />.</summary>
+        /// <summary>Converts a <see cref="Vector64{Single}" /> to a <see cref="Vector64{Int32}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -357,7 +357,14 @@ public static unsafe Vector64<int> ConvertToInt32(Vector64<float> vector)
             return result;
         }
 
-        /// <summary>Converts a <see cref="Vector64{Double}" /> to a <see cref="Vector64{Int64}" />.</summary>
+        /// <summary>Converts a <see cref="Vector64{Single}" /> to a <see cref="Vector64{Int32}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Vector64<int> ConvertToInt32Native(Vector64<float> vector) => ConvertToInt32(vector);
+
+        /// <summary>Converts a <see cref="Vector64{Double}" /> to a <see cref="Vector64{Int64}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -375,6 +382,13 @@ public static unsafe Vector64<long> ConvertToInt64(Vector64<double> vector)
             return result;
         }
 
+        /// <summary>Converts a <see cref="Vector64{Double}" /> to a <see cref="Vector64{Int64}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Vector64<long> ConvertToInt64Native(Vector64<double> vector) => ConvertToInt64(vector);
+
         /// <summary>Converts a <see cref="Vector64{Int32}" /> to a <see cref="Vector64{Single}" />.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
@@ -412,7 +426,7 @@ public static unsafe Vector64<float> ConvertToSingle(Vector64<uint> vector)
             return result;
         }
 
-        /// <summary>Converts a <see cref="Vector64{Single}" /> to a <see cref="Vector64{UInt32}" />.</summary>
+        /// <summary>Converts a <see cref="Vector64{Single}" /> to a <see cref="Vector64{UInt32}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -431,7 +445,15 @@ public static unsafe Vector64<uint> ConvertToUInt32(Vector64<float> vector)
             return result;
         }
 
-        /// <summary>Converts a <see cref="Vector64{Double}" /> to a <see cref="Vector64{UInt64}" />.</summary>
+        /// <summary>Converts a <see cref="Vector64{Single}" /> to a <see cref="Vector64{UInt32}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Vector64<uint> ConvertToUInt32Native(Vector64<float> vector) => ConvertToUInt32(vector);
+
+        /// <summary>Converts a <see cref="Vector64{Double}" /> to a <see cref="Vector64{UInt64}" /> using saturation on overflow.</summary>
         /// <param name="vector">The vector to convert.</param>
         /// <returns>The converted vector.</returns>
         [Intrinsic]
@@ -450,6 +472,14 @@ public static unsafe Vector64<ulong> ConvertToUInt64(Vector64<double> vector)
             return result;
         }
 
+        /// <summary>Converts a <see cref="Vector64{Double}" /> to a <see cref="Vector64{UInt64}" /> using platform specific behavior on overflow.</summary>
+        /// <param name="vector">The vector to convert.</param>
+        /// <returns>The converted vector.</returns>
+        [Intrinsic]
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Vector64<ulong> ConvertToUInt64Native(Vector64<double> vector) => ConvertToUInt64(vector);
+
         /// <summary>Copies a <see cref="Vector64{T}" /> to a given array.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="vector">The vector to be copied.</param>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Single.cs b/src/libraries/System.Private.CoreLib/src/System/Single.cs
index 9cc7c6b56c0ad..8a8a38aa2c0b4 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Single.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Single.cs
@@ -650,6 +650,16 @@ public static bool IsPow2(float value)
         [Intrinsic]
         public static float Ceiling(float x) => MathF.Ceiling(x);
 
+        /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToInteger{TInteger}(TSelf)" />
+        [Intrinsic]
+        public static TInteger ConvertToInteger<TInteger>(float value)
+            where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);
+
+        /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToIntegerNative{TInteger}(TSelf)" />
+        [Intrinsic]
+        public static TInteger ConvertToIntegerNative<TInteger>(float value)
+            where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);
+
         /// <inheritdoc cref="IFloatingPoint{TSelf}.Floor(TSelf)" />
         [Intrinsic]
         public static float Floor(float x) => MathF.Floor(x);
diff --git a/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs b/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
index c0fe858d94c60..3b718d224417c 100644
--- a/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
+++ b/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
@@ -1341,6 +1341,8 @@ public static unsafe partial class NativeMemory
         public static System.Runtime.InteropServices.NFloat Clamp(System.Runtime.InteropServices.NFloat value, System.Runtime.InteropServices.NFloat min, System.Runtime.InteropServices.NFloat max) { throw null; }
         public int CompareTo(object? obj) { throw null; }
         public int CompareTo(System.Runtime.InteropServices.NFloat other) { throw null; }
+        public static TInteger ConvertToInteger<TInteger>(System.Runtime.InteropServices.NFloat value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
+        public static TInteger ConvertToIntegerNative<TInteger>(System.Runtime.InteropServices.NFloat value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
         public static System.Runtime.InteropServices.NFloat CopySign(System.Runtime.InteropServices.NFloat value, System.Runtime.InteropServices.NFloat sign) { throw null; }
         public static System.Runtime.InteropServices.NFloat Cos(System.Runtime.InteropServices.NFloat x) { throw null; }
         public static System.Runtime.InteropServices.NFloat Cosh(System.Runtime.InteropServices.NFloat x) { throw null; }
diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
index 77fe06ddc5c02..d2915ae6eb55e 100644
--- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
+++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
@@ -49,14 +49,20 @@ public static partial class Vector128
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector128<System.Double> ConvertToDouble(System.Runtime.Intrinsics.Vector128<System.UInt64> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<System.Int32> ConvertToInt32(System.Runtime.Intrinsics.Vector128<System.Single> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<System.Int32> ConvertToInt32Native(System.Runtime.Intrinsics.Vector128<System.Single> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<System.Int64> ConvertToInt64(System.Runtime.Intrinsics.Vector128<System.Double> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<System.Int64> ConvertToInt64Native(System.Runtime.Intrinsics.Vector128<System.Double> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<System.Single> ConvertToSingle(System.Runtime.Intrinsics.Vector128<System.Int32> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector128<System.Single> ConvertToSingle(System.Runtime.Intrinsics.Vector128<System.UInt32> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector128<System.UInt32> ConvertToUInt32(System.Runtime.Intrinsics.Vector128<System.Single> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
+        public static System.Runtime.Intrinsics.Vector128<System.UInt32> ConvertToUInt32Native(System.Runtime.Intrinsics.Vector128<System.Single> vector) { throw null; }
+        [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector128<System.UInt64> ConvertToUInt64(System.Runtime.Intrinsics.Vector128<System.Double> vector) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static System.Runtime.Intrinsics.Vector128<System.UInt64> ConvertToUInt64Native(System.Runtime.Intrinsics.Vector128<System.Double> vector) { throw null; }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector128<T> vector, System.Span<T> destination) { }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector128<T> vector, T[] destination) { }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector128<T> vector, T[] destination, int startIndex) { }
@@ -384,14 +390,20 @@ public static partial class Vector256
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector256<System.Double> ConvertToDouble(System.Runtime.Intrinsics.Vector256<System.UInt64> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<System.Int32> ConvertToInt32(System.Runtime.Intrinsics.Vector256<System.Single> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<System.Int32> ConvertToInt32Native(System.Runtime.Intrinsics.Vector256<System.Single> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<System.Int64> ConvertToInt64(System.Runtime.Intrinsics.Vector256<System.Double> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<System.Int64> ConvertToInt64Native(System.Runtime.Intrinsics.Vector256<System.Double> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<System.Single> ConvertToSingle(System.Runtime.Intrinsics.Vector256<System.Int32> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector256<System.Single> ConvertToSingle(System.Runtime.Intrinsics.Vector256<System.UInt32> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector256<System.UInt32> ConvertToUInt32(System.Runtime.Intrinsics.Vector256<System.Single> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
+        public static System.Runtime.Intrinsics.Vector256<System.UInt32> ConvertToUInt32Native(System.Runtime.Intrinsics.Vector256<System.Single> vector) { throw null; }
+        [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector256<System.UInt64> ConvertToUInt64(System.Runtime.Intrinsics.Vector256<System.Double> vector) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static System.Runtime.Intrinsics.Vector256<System.UInt64> ConvertToUInt64Native(System.Runtime.Intrinsics.Vector256<System.Double> vector) { throw null; }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector256<T> vector, System.Span<T> destination) { }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector256<T> vector, T[] destination) { }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector256<T> vector, T[] destination, int startIndex) { }
@@ -719,14 +731,20 @@ public static partial class Vector512
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector512<System.Double> ConvertToDouble(System.Runtime.Intrinsics.Vector512<System.UInt64> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector512<System.Int32> ConvertToInt32(System.Runtime.Intrinsics.Vector512<System.Single> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector512<System.Int32> ConvertToInt32Native(System.Runtime.Intrinsics.Vector512<System.Single> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector512<System.Int64> ConvertToInt64(System.Runtime.Intrinsics.Vector512<System.Double> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector512<System.Int64> ConvertToInt64Native(System.Runtime.Intrinsics.Vector512<System.Double> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector512<System.Single> ConvertToSingle(System.Runtime.Intrinsics.Vector512<System.Int32> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector512<System.Single> ConvertToSingle(System.Runtime.Intrinsics.Vector512<System.UInt32> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector512<System.UInt32> ConvertToUInt32(System.Runtime.Intrinsics.Vector512<System.Single> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
+        public static System.Runtime.Intrinsics.Vector512<System.UInt32> ConvertToUInt32Native(System.Runtime.Intrinsics.Vector512<System.Single> vector) { throw null; }
+        [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector512<System.UInt64> ConvertToUInt64(System.Runtime.Intrinsics.Vector512<System.Double> vector) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static System.Runtime.Intrinsics.Vector512<System.UInt64> ConvertToUInt64Native(System.Runtime.Intrinsics.Vector512<System.Double> vector) { throw null; }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector512<T> vector, System.Span<T> destination) { }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector512<T> vector, T[] destination) { }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector512<T> vector, T[] destination, int startIndex) { }
@@ -1050,14 +1068,20 @@ public static partial class Vector64
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector64<System.Double> ConvertToDouble(System.Runtime.Intrinsics.Vector64<System.UInt64> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<System.Int32> ConvertToInt32(System.Runtime.Intrinsics.Vector64<System.Single> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<System.Int32> ConvertToInt32Native(System.Runtime.Intrinsics.Vector64<System.Single> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<System.Int64> ConvertToInt64(System.Runtime.Intrinsics.Vector64<System.Double> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<System.Int64> ConvertToInt64Native(System.Runtime.Intrinsics.Vector64<System.Double> vector) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<System.Single> ConvertToSingle(System.Runtime.Intrinsics.Vector64<System.Int32> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector64<System.Single> ConvertToSingle(System.Runtime.Intrinsics.Vector64<System.UInt32> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector64<System.UInt32> ConvertToUInt32(System.Runtime.Intrinsics.Vector64<System.Single> vector) { throw null; }
         [System.CLSCompliantAttribute(false)]
+        public static System.Runtime.Intrinsics.Vector64<System.UInt32> ConvertToUInt32Native(System.Runtime.Intrinsics.Vector64<System.Single> vector) { throw null; }
+        [System.CLSCompliantAttribute(false)]
         public static System.Runtime.Intrinsics.Vector64<System.UInt64> ConvertToUInt64(System.Runtime.Intrinsics.Vector64<System.Double> vector) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static System.Runtime.Intrinsics.Vector64<System.UInt64> ConvertToUInt64Native(System.Runtime.Intrinsics.Vector64<System.Double> vector) { throw null; }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector64<T> vector, System.Span<T> destination) { }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector64<T> vector, T[] destination) { }
         public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector64<T> vector, T[] destination, int startIndex) { }
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index 0371e3037e265..688d7f4729263 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -4,6 +4,8 @@
 // Changes to this file must follow the https://aka.ms/api-review process.
 // ------------------------------------------------------------------------------
 
+using System.Numerics;
+
 namespace Microsoft.Win32.SafeHandles
 {
     public abstract partial class CriticalHandleMinusOneIsInvalid : System.Runtime.InteropServices.CriticalHandle
@@ -1985,6 +1987,8 @@ public sealed partial class DBNull : System.IConvertible, System.Runtime.Seriali
         public static int Compare(decimal d1, decimal d2) { throw null; }
         public int CompareTo(decimal value) { throw null; }
         public int CompareTo(object? value) { throw null; }
+        public static TInteger ConvertToInteger<TInteger>(decimal value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
+        public static TInteger ConvertToIntegerNative<TInteger>(decimal value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
         public static decimal CopySign(decimal value, decimal sign) { throw null; }
         public static decimal CreateChecked<TOther>(TOther value) where TOther : System.Numerics.INumberBase<TOther> { throw null; }
         public static decimal CreateSaturating<TOther>(TOther value) where TOther : System.Numerics.INumberBase<TOther> { throw null; }
@@ -2258,6 +2262,8 @@ public partial class DivideByZeroException : System.ArithmeticException
         public static double Clamp(double value, double min, double max) { throw null; }
         public int CompareTo(double value) { throw null; }
         public int CompareTo(object? value) { throw null; }
+        public static TInteger ConvertToInteger<TInteger>(double value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
+        public static TInteger ConvertToIntegerNative<TInteger>(double value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
         public static double CopySign(double value, double sign) { throw null; }
         public static double Cos(double x) { throw null; }
         public static double Cosh(double x) { throw null; }
@@ -2880,6 +2886,8 @@ public enum GCNotificationStatus
         public static System.Half Clamp(System.Half value, System.Half min, System.Half max) { throw null; }
         public int CompareTo(System.Half other) { throw null; }
         public int CompareTo(object? obj) { throw null; }
+        public static TInteger ConvertToInteger<TInteger>(System.Half value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
+        public static TInteger ConvertToIntegerNative<TInteger>(System.Half value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
         public static System.Half CopySign(System.Half value, System.Half sign) { throw null; }
         public static System.Half Cos(System.Half x) { throw null; }
         public static System.Half Cosh(System.Half x) { throw null; }
@@ -4997,6 +5005,8 @@ public sealed partial class SerializableAttribute : System.Attribute
         public static float Clamp(float value, float min, float max) { throw null; }
         public int CompareTo(object? value) { throw null; }
         public int CompareTo(float value) { throw null; }
+        public static TInteger ConvertToInteger<TInteger>(float value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
+        public static TInteger ConvertToIntegerNative<TInteger>(float value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
         public static float CopySign(float value, float sign) { throw null; }
         public static float Cos(float x) { throw null; }
         public static float Cosh(float x) { throw null; }
@@ -10789,6 +10799,8 @@ public partial interface IFloatingPointIeee754<TSelf> : System.IComparable, Syst
     public partial interface IFloatingPoint<TSelf> : System.IComparable, System.IComparable<TSelf>, System.IEquatable<TSelf>, System.IFormattable, System.IParsable<TSelf>, System.ISpanFormattable, System.ISpanParsable<TSelf>, System.Numerics.IAdditionOperators<TSelf, TSelf, TSelf>, System.Numerics.IAdditiveIdentity<TSelf, TSelf>, System.Numerics.IComparisonOperators<TSelf, TSelf, bool>, System.Numerics.IDecrementOperators<TSelf>, System.Numerics.IDivisionOperators<TSelf, TSelf, TSelf>, System.Numerics.IEqualityOperators<TSelf, TSelf, bool>, System.Numerics.IFloatingPointConstants<TSelf>, System.Numerics.IIncrementOperators<TSelf>, System.Numerics.IModulusOperators<TSelf, TSelf, TSelf>, System.Numerics.IMultiplicativeIdentity<TSelf, TSelf>, System.Numerics.IMultiplyOperators<TSelf, TSelf, TSelf>, System.Numerics.INumber<TSelf>, System.Numerics.INumberBase<TSelf>, System.Numerics.ISignedNumber<TSelf>, System.Numerics.ISubtractionOperators<TSelf, TSelf, TSelf>, System.Numerics.IUnaryNegationOperators<TSelf, TSelf>, System.Numerics.IUnaryPlusOperators<TSelf, TSelf> where TSelf : System.Numerics.IFloatingPoint<TSelf>?
     {
         static virtual TSelf Ceiling(TSelf x) { throw null; }
+        static virtual TInteger ConvertToInteger<TInteger>(TSelf value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
+        static virtual TInteger ConvertToIntegerNative<TInteger>(TSelf value) where TInteger : System.Numerics.IBinaryInteger<TInteger> { throw null; }
         static virtual TSelf Floor(TSelf x) { throw null; }
         int GetExponentByteCount();
         int GetExponentShortestBitLength();

From 932032de30a2d366af94e8582f915c7485a1b53a Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 12 Apr 2024 12:55:22 -0700
Subject: [PATCH 2/4] Accelerate the ConvertToInteger and related APIs

---
 src/coreclr/jit/compiler.h                    |  22 +-
 src/coreclr/jit/emit.h                        |   4 +
 src/coreclr/jit/gentree.cpp                   | 259 +++++++++++++-----
 src/coreclr/jit/hwintrinsicarm64.cpp          |  26 +-
 src/coreclr/jit/hwintrinsiclistarm64.h        |   8 +
 src/coreclr/jit/hwintrinsiclistxarch.h        |  14 +-
 src/coreclr/jit/hwintrinsicxarch.cpp          | 108 ++++++--
 src/coreclr/jit/importercalls.cpp             | 128 ++++++++-
 src/coreclr/jit/namedintrinsiclist.h          |   2 +
 src/coreclr/jit/simdashwintrinsic.cpp         | 101 +++----
 src/coreclr/jit/simdashwintrinsiclistarm64.h  |   4 +
 src/coreclr/jit/simdashwintrinsiclistxarch.h  |   4 +
 .../Common/tests/System/GenericMathHelpers.cs |   6 +
 .../tests/Vectors/Vector128Tests.cs           |  96 +++++++
 .../tests/Vectors/Vector256Tests.cs           |  96 +++++++
 .../tests/Vectors/Vector512Tests.cs           |  96 +++++++
 .../tests/Vectors/Vector64Tests.cs            |  65 +++++
 .../System/DoubleTests.GenericMath.cs         | 181 ++++++++++++
 .../System/SingleTests.GenericMath.cs         | 184 +++++++++++++
 19 files changed, 1230 insertions(+), 174 deletions(-)

diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h
index a9ec6f595ab5a..8434c625b91a7 100644
--- a/src/coreclr/jit/compiler.h
+++ b/src/coreclr/jit/compiler.h
@@ -1589,7 +1589,7 @@ enum class ProfileChecks : unsigned int
     CHECK_NONE          = 0,
     CHECK_CLASSIC       = 1 << 0, // check "classic" jit weights
     CHECK_HASLIKELIHOOD = 1 << 1, // check all FlowEdges for hasLikelihood
-    CHECK_LIKELIHOODSUM = 1 << 2, // check block successor likelihoods sum to 1                              
+    CHECK_LIKELIHOODSUM = 1 << 2, // check block successor likelihoods sum to 1
     CHECK_LIKELY        = 1 << 3, // fully check likelihood based weights
     RAISE_ASSERT        = 1 << 4, // assert on check failure
     CHECK_ALL_BLOCKS    = 1 << 5, // check blocks even if bbHasProfileWeight is false
@@ -3183,13 +3183,17 @@ class Compiler
                                  CorInfoType simdBaseJitType,
                                  unsigned    simdSize);
 
-#if defined(TARGET_XARCH)
-    GenTree* gtNewSimdCvtNode(var_types              type,
-                              GenTree*               op1,
-                              CorInfoType            simdTargetBaseJitType,
-                              CorInfoType            simdSourceBaseJitType,
-                              unsigned               simdSize);
-#endif //TARGET_XARCH
+    GenTree* gtNewSimdCvtNode(var_types   type,
+                              GenTree*    op1,
+                              CorInfoType simdTargetBaseJitType,
+                              CorInfoType simdSourceBaseJitType,
+                              unsigned    simdSize);
+
+    GenTree* gtNewSimdCvtNativeNode(var_types   type,
+                                    GenTree*    op1,
+                                    CorInfoType simdTargetBaseJitType,
+                                    CorInfoType simdSourceBaseJitType,
+                                    unsigned    simdSize);
 
     GenTree* gtNewSimdCreateBroadcastNode(
         var_types type, GenTree* op1, CorInfoType simdBaseJitType, unsigned simdSize);
@@ -5921,7 +5925,7 @@ class Compiler
     void fgReplaceEhfSuccessor(BasicBlock* block, BasicBlock* oldSucc, BasicBlock* newSucc);
 
     void fgRemoveEhfSuccessor(BasicBlock* block, const unsigned succIndex);
-    
+
     void fgRemoveEhfSuccessor(FlowEdge* succEdge);
 
     void fgReplaceJumpTarget(BasicBlock* block, BasicBlock* oldTarget, BasicBlock* newTarget);
diff --git a/src/coreclr/jit/emit.h b/src/coreclr/jit/emit.h
index 40a729dd70fee..4fb37df514911 100644
--- a/src/coreclr/jit/emit.h
+++ b/src/coreclr/jit/emit.h
@@ -4020,6 +4020,8 @@ emitAttr emitter::emitGetBaseMemOpSize(instrDesc* id) const
         case INS_subss:
         case INS_ucomiss:
         case INS_vbroadcastss:
+        case INS_vcvttss2usi32:
+        case INS_vcvttss2usi64:
         case INS_vfmadd132ss:
         case INS_vfmadd213ss:
         case INS_vfmadd231ss:
@@ -4067,6 +4069,8 @@ emitAttr emitter::emitGetBaseMemOpSize(instrDesc* id) const
         case INS_subsd:
         case INS_ucomisd:
         case INS_vbroadcastsd:
+        case INS_vcvttsd2usi32:
+        case INS_vcvttsd2usi64:
         case INS_vfmadd132sd:
         case INS_vfmadd213sd:
         case INS_vfmadd231sd:
diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
index 7e90d26a3d682..08ea188f49f8e 100644
--- a/src/coreclr/jit/gentree.cpp
+++ b/src/coreclr/jit/gentree.cpp
@@ -21346,7 +21346,6 @@ GenTree* Compiler::gtNewSimdCeilNode(var_types type, GenTree* op1, CorInfoType s
     return gtNewSimdHWIntrinsicNode(type, op1, intrinsic, simdBaseJitType, simdSize);
 }
 
-#if defined(TARGET_XARCH)
 GenTree* Compiler::gtNewSimdCvtNode(var_types   type,
                                     GenTree*    op1,
                                     CorInfoType simdTargetBaseJitType,
@@ -21364,12 +21363,127 @@ GenTree* Compiler::gtNewSimdCvtNode(var_types   type,
     assert(varTypeIsIntegral(simdTargetBaseType));
 
     assert(IsBaselineSimdIsaSupportedDebugOnly());
+
+#if defined(TARGET_XARCH)
     assert(IsBaselineVector512IsaSupportedDebugOnly() ||
            ((simdTargetBaseType == TYP_INT) && ((simdSize == 16 && compIsaSupportedDebugOnly(InstructionSet_SSE41)) ||
                                                 (simdSize == 32 && compIsaSupportedDebugOnly(InstructionSet_AVX)))));
 
+    GenTree* fixupVal;
+
+    if (IsBaselineVector512IsaSupportedOpportunistically())
+    {
+        /*Generate the control table for VFIXUPIMMSD/SS
+        - For conversion to unsigned
+                    // QNAN: 0b1000: Saturate to Zero
+                    // SNAN: 0b1000: Saturate to Zero
+                    // ZERO: 0b0000
+                    // +ONE: 0b0000
+                    // -INF: 0b1000: Saturate to Zero
+                    // +INF: 0b0000
+                    // -VAL: 0b1000: Saturate to Zero
+                    // +VAL: 0b0000
+        - For conversion to signed
+                    // QNAN: 0b1000: Saturate to Zero
+                    // SNAN: 0b1000: Saturate to Zero
+                    // ZERO: 0b0000
+                    // +ONE: 0b0000
+                    // -INF: 0b0000
+                    // +INF: 0b0000
+                    // -VAL: 0b0000
+                    // +VAL: 0b0000
+        */
+        int32_t  iconVal = varTypeIsUnsigned(simdTargetBaseType) ? 0x08080088 : 0x00000088;
+        GenTree* tblCon  = gtNewSimdCreateBroadcastNode(type, gtNewIconNode(iconVal), simdTargetBaseJitType, simdSize);
+
+        // We need op1Clone to run fixup
+        GenTree* op1Clone = fgMakeMultiUse(&op1);
+
+        // run vfixupimmsd base on table and no flags reporting
+        fixupVal = gtNewSimdHWIntrinsicNode(type, op1, op1Clone, tblCon, gtNewIconNode(0), NI_AVX512F_Fixup,
+                                            simdSourceBaseJitType, simdSize);
+    }
+    else
+    {
+        // Zero out NaN values from the input.
+        // mask1 contains the output either 0xFFFFFFFF or 0.
+        // FixupVal zeros out any NaN values in the input by ANDing input with mask1.
+        GenTree* op1Clone1 = fgMakeMultiUse(&op1);
+        GenTree* op1Clone2 = fgMakeMultiUse(&op1);
+        GenTree* mask1     = gtNewSimdCmpOpNode(GT_EQ, type, op1, op1Clone1, simdSourceBaseJitType, simdSize);
+        fixupVal           = gtNewSimdBinOpNode(GT_AND, type, op1Clone2, mask1, simdSourceBaseJitType, simdSize);
+    }
+
+    if (varTypeIsSigned(simdTargetBaseType))
+    {
+        GenTree* maxVal;
+        GenTree* maxValDup;
+        if (varTypeIsLong(simdTargetBaseType))
+        {
+            int64_t actualMaxVal = INT64_MAX;
+            maxVal               = gtNewDconNode(static_cast<double>(actualMaxVal), simdSourceBaseType);
+            maxVal               = gtNewSimdCreateBroadcastNode(type, maxVal, simdSourceBaseJitType, simdSize);
+            maxValDup =
+                gtNewSimdCreateBroadcastNode(type, gtNewLconNode(actualMaxVal), simdTargetBaseJitType, simdSize);
+        }
+        else
+        {
+            ssize_t actualMaxVal = INT32_MAX;
+            maxVal               = gtNewDconNode(static_cast<double>(actualMaxVal), simdSourceBaseType);
+            maxVal               = gtNewSimdCreateBroadcastNode(type, maxVal, simdSourceBaseJitType, simdSize);
+            maxValDup =
+                gtNewSimdCreateBroadcastNode(type, gtNewIconNode(actualMaxVal), simdTargetBaseJitType, simdSize);
+        }
+
+        // we will be using the input value twice
+        GenTree* fixupValDup = fgMakeMultiUse(&fixupVal);
+
+        // compare with max value of integer/long
+        fixupVal = gtNewSimdCmpOpNode(GT_GE, type, fixupVal, maxVal, simdSourceBaseJitType, simdSize);
+
+        // cast it
+        GenTree* castNode = gtNewSimdCvtNativeNode(type, fixupValDup, simdTargetBaseJitType, simdSourceBaseJitType, simdSize);
+
+        // use the fixupVal mask with input value and max value to blend
+        return gtNewSimdCndSelNode(type, fixupVal, maxValDup, castNode, simdTargetBaseJitType, simdSize);
+    }
+    else
+    {
+        return gtNewSimdCvtNativeNode(type, fixupVal, simdTargetBaseJitType, simdSourceBaseJitType, simdSize);
+    }
+#elif defined(TARGET_ARM64)
+    return gtNewSimdCvtNativeNode(type, op1, simdTargetBaseJitType, simdSourceBaseJitType, simdSize);
+#else
+#error Unsupported platform
+#endif // !TARGET_XARCH && !TARGET_ARM64
+}
+
+GenTree* Compiler::gtNewSimdCvtNativeNode(var_types   type,
+                                          GenTree*    op1,
+                                          CorInfoType simdTargetBaseJitType,
+                                          CorInfoType simdSourceBaseJitType,
+                                          unsigned    simdSize)
+{
+    assert(varTypeIsSIMD(type));
+    assert(getSIMDTypeForSize(simdSize) == type);
+    assert(op1 != nullptr);
+    assert(op1->TypeIs(type));
+
+    var_types simdSourceBaseType = JitType2PreciseVarType(simdSourceBaseJitType);
+    var_types simdTargetBaseType = JitType2PreciseVarType(simdTargetBaseJitType);
+    assert(varTypeIsFloating(simdSourceBaseType));
+    assert(varTypeIsIntegral(simdTargetBaseType));
+
+    assert(IsBaselineSimdIsaSupportedDebugOnly());
+
     // Generate intrinsic needed for conversion
     NamedIntrinsic hwIntrinsicID = NI_Illegal;
+
+#if defined(TARGET_XARCH)
+    assert(IsBaselineVector512IsaSupportedDebugOnly() ||
+           ((simdTargetBaseType == TYP_INT) && ((simdSize == 16) ||
+                                                (simdSize == 32 && compIsaSupportedDebugOnly(InstructionSet_AVX)))));
+
     switch (simdSourceBaseJitType)
     {
         case CORINFO_TYPE_FLOAT:
@@ -21385,21 +21499,25 @@ GenTree* Compiler::gtNewSimdCvtNode(var_types   type,
                             hwIntrinsicID = NI_AVX512F_ConvertToVector512Int32WithTruncation;
                             break;
                         }
+
                         case 32:
                         {
                             hwIntrinsicID = NI_AVX_ConvertToVector256Int32WithTruncation;
                             break;
                         }
+
                         case 16:
                         {
                             hwIntrinsicID = NI_SSE2_ConvertToVector128Int32WithTruncation;
                             break;
                         }
+
                         default:
                             unreached();
                     }
                     break;
                 }
+
                 case CORINFO_TYPE_UINT:
                 {
                     switch (simdSize)
@@ -21409,26 +21527,31 @@ GenTree* Compiler::gtNewSimdCvtNode(var_types   type,
                             hwIntrinsicID = NI_AVX512F_ConvertToVector512UInt32WithTruncation;
                             break;
                         }
+
                         case 32:
                         {
                             hwIntrinsicID = NI_AVX512F_VL_ConvertToVector256UInt32WithTruncation;
                             break;
                         }
+
                         case 16:
                         {
                             hwIntrinsicID = NI_AVX512F_VL_ConvertToVector128UInt32WithTruncation;
                             break;
                         }
+
                         default:
                             unreached();
                     }
                     break;
                 }
+
                 default:
                     unreached();
             }
             break;
         }
+
         case CORINFO_TYPE_DOUBLE:
         {
             switch (simdTargetBaseJitType)
@@ -21442,21 +21565,25 @@ GenTree* Compiler::gtNewSimdCvtNode(var_types   type,
                             hwIntrinsicID = NI_AVX512DQ_ConvertToVector512Int64WithTruncation;
                             break;
                         }
+
                         case 32:
                         {
                             hwIntrinsicID = NI_AVX512DQ_VL_ConvertToVector256Int64WithTruncation;
                             break;
                         }
+
                         case 16:
                         {
                             hwIntrinsicID = NI_AVX512DQ_VL_ConvertToVector128Int64WithTruncation;
                             break;
                         }
+
                         default:
                             unreached();
                     }
                     break;
                 }
+
                 case CORINFO_TYPE_ULONG:
                 {
                     switch (simdSize)
@@ -21466,115 +21593,95 @@ GenTree* Compiler::gtNewSimdCvtNode(var_types   type,
                             hwIntrinsicID = NI_AVX512DQ_ConvertToVector512UInt64WithTruncation;
                             break;
                         }
+
                         case 32:
                         {
                             hwIntrinsicID = NI_AVX512DQ_VL_ConvertToVector256UInt64WithTruncation;
                             break;
                         }
+
                         case 16:
                         {
                             hwIntrinsicID = NI_AVX512DQ_VL_ConvertToVector128UInt64WithTruncation;
                             break;
                         }
+
                         default:
                             unreached();
                     }
                     break;
                 }
+
                 default:
                     unreached();
             }
             break;
         }
+
         default:
             unreached();
     }
-    assert(hwIntrinsicID != NI_Illegal);
-
-    GenTree* fixupVal;
+#elif defined(TARGET_ARM64)
+    assert((simdSize == 8) || (simdSize == 16));
 
-    if (IsBaselineVector512IsaSupportedOpportunistically())
+    switch (simdSourceBaseJitType)
     {
-        /*Generate the control table for VFIXUPIMMSD/SS
-        - For conversion to unsigned
-                    // QNAN: 0b1000: Saturate to Zero
-                    // SNAN: 0b1000: Saturate to Zero
-                    // ZERO: 0b0000
-                    // +ONE: 0b0000
-                    // -INF: 0b1000: Saturate to Zero
-                    // +INF: 0b0000
-                    // -VAL: 0b1000: Saturate to Zero
-                    // +VAL: 0b0000
-        - For conversion to signed
-                    // QNAN: 0b1000: Saturate to Zero
-                    // SNAN: 0b1000: Saturate to Zero
-                    // ZERO: 0b0000
-                    // +ONE: 0b0000
-                    // -INF: 0b0000
-                    // +INF: 0b0000
-                    // -VAL: 0b0000
-                    // +VAL: 0b0000
-        */
-        int32_t  iconVal = varTypeIsUnsigned(simdTargetBaseType) ? 0x08080088 : 0x00000088;
-        GenTree* tblCon  = gtNewSimdCreateBroadcastNode(type, gtNewIconNode(iconVal), simdTargetBaseJitType, simdSize);
-
-        // We need op1Clone to run fixup
-        GenTree* op1Clone = fgMakeMultiUse(&op1);
+        case CORINFO_TYPE_FLOAT:
+        {
+            switch (simdTargetBaseJitType)
+            {
+                case CORINFO_TYPE_INT:
+                {
+                    hwIntrinsicID = NI_AdvSimd_ConvertToInt32RoundToZero;
+                    break;
+                }
 
-        // run vfixupimmsd base on table and no flags reporting
-        fixupVal = gtNewSimdHWIntrinsicNode(type, op1, op1Clone, tblCon, gtNewIconNode(0), NI_AVX512F_Fixup,
-                                            simdSourceBaseJitType, simdSize);
-    }
-    else
-    {
-        // Zero out NaN values from the input.
-        // mask1 contains the output either 0xFFFFFFFF or 0.
-        // FixupVal zeros out any NaN values in the input by ANDing input with mask1.
-        GenTree* op1Clone1 = fgMakeMultiUse(&op1);
-        GenTree* op1Clone2 = fgMakeMultiUse(&op1);
-        GenTree* mask1     = gtNewSimdCmpOpNode(GT_EQ, type, op1, op1Clone1, simdSourceBaseJitType, simdSize);
-        fixupVal           = gtNewSimdBinOpNode(GT_AND, type, op1Clone2, mask1, simdSourceBaseJitType, simdSize);
-    }
+                case CORINFO_TYPE_UINT:
+                {
+                    hwIntrinsicID = NI_AdvSimd_ConvertToUInt32RoundToZero;
+                    break;
+                }
 
-    if (varTypeIsSigned(simdTargetBaseType))
-    {
-        GenTree* maxVal;
-        GenTree* maxValDup;
-        if (varTypeIsLong(simdTargetBaseType))
-        {
-            int64_t actualMaxVal = INT64_MAX;
-            maxVal               = gtNewDconNode(static_cast<double>(actualMaxVal), simdSourceBaseType);
-            maxVal               = gtNewSimdCreateBroadcastNode(type, maxVal, simdSourceBaseJitType, simdSize);
-            maxValDup =
-                gtNewSimdCreateBroadcastNode(type, gtNewLconNode(actualMaxVal), simdTargetBaseJitType, simdSize);
-        }
-        else
-        {
-            ssize_t actualMaxVal = INT32_MAX;
-            maxVal               = gtNewDconNode(static_cast<double>(actualMaxVal), simdSourceBaseType);
-            maxVal               = gtNewSimdCreateBroadcastNode(type, maxVal, simdSourceBaseJitType, simdSize);
-            maxValDup =
-                gtNewSimdCreateBroadcastNode(type, gtNewIconNode(actualMaxVal), simdTargetBaseJitType, simdSize);
+                default:
+                    unreached();
+            }
+            break;
         }
 
-        // we will be using the input value twice
-        GenTree* fixupValDup = fgMakeMultiUse(&fixupVal);
+        case CORINFO_TYPE_DOUBLE:
+        {
+            switch (simdTargetBaseJitType)
+            {
+                case CORINFO_TYPE_LONG:
+                {
+                    hwIntrinsicID = (simdSize == 8) ? NI_AdvSimd_Arm64_ConvertToInt64RoundToZeroScalar
+                                                    : NI_AdvSimd_Arm64_ConvertToInt64RoundToZero;
+                    break;
+                }
 
-        // compare with max value of integer/long
-        fixupVal = gtNewSimdCmpOpNode(GT_GE, type, fixupVal, maxVal, simdSourceBaseJitType, simdSize);
+                case CORINFO_TYPE_ULONG:
+                {
+                    hwIntrinsicID = (simdSize == 8) ? NI_AdvSimd_Arm64_ConvertToUInt64RoundToZeroScalar
+                                                    : NI_AdvSimd_Arm64_ConvertToUInt64RoundToZero;
+                    break;
+                }
 
-        // cast it
-        GenTree* castNode = gtNewSimdHWIntrinsicNode(type, fixupValDup, hwIntrinsicID, simdSourceBaseJitType, simdSize);
+                default:
+                    unreached();
+            }
+            break;
+        }
 
-        // use the fixupVal mask with input value and max value to blend
-        return gtNewSimdCndSelNode(type, fixupVal, maxValDup, castNode, simdTargetBaseJitType, simdSize);
-    }
-    else
-    {
-        return gtNewSimdHWIntrinsicNode(type, fixupVal, hwIntrinsicID, simdSourceBaseJitType, simdSize);
+        default:
+            unreached();
     }
+#else
+#error Unsupported platform
+#endif // !TARGET_XARCH && !TARGET_ARM64
+
+    assert(hwIntrinsicID != NI_Illegal);
+    return gtNewSimdHWIntrinsicNode(type, op1, hwIntrinsicID, simdSourceBaseJitType, simdSize);
 }
-#endif // TARGET_XARCH
 
 GenTree* Compiler::gtNewSimdCmpOpNode(
     genTreeOps op, var_types type, GenTree* op1, GenTree* op2, CorInfoType simdBaseJitType, unsigned simdSize)
diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp
index 8e3288f75d709..98342739cb4e0 100644
--- a/src/coreclr/jit/hwintrinsicarm64.cpp
+++ b/src/coreclr/jit/hwintrinsicarm64.cpp
@@ -621,28 +621,28 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
         }
 
         case NI_Vector64_ConvertToInt32:
+        case NI_Vector64_ConvertToInt32Native:
         case NI_Vector128_ConvertToInt32:
+        case NI_Vector128_ConvertToInt32Native:
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_FLOAT);
 
-            op1 = impSIMDPopStack();
-            retNode =
-                gtNewSimdHWIntrinsicNode(retType, op1, NI_AdvSimd_ConvertToInt32RoundToZero, simdBaseJitType, simdSize);
+            op1     = impSIMDPopStack();
+            retNode = gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_INT, simdBaseJitType, simdSize);
             break;
         }
 
         case NI_Vector64_ConvertToInt64:
+        case NI_Vector64_ConvertToInt64Native:
         case NI_Vector128_ConvertToInt64:
+        case NI_Vector128_ConvertToInt64Native:
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_DOUBLE);
 
-            intrinsic = (simdSize == 8) ? NI_AdvSimd_Arm64_ConvertToInt64RoundToZeroScalar
-                                        : NI_AdvSimd_Arm64_ConvertToInt64RoundToZero;
-
             op1     = impSIMDPopStack();
-            retNode = gtNewSimdHWIntrinsicNode(retType, op1, intrinsic, simdBaseJitType, simdSize);
+            retNode = gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_LONG, simdBaseJitType, simdSize);
             break;
         }
 
@@ -658,28 +658,28 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
         }
 
         case NI_Vector64_ConvertToUInt32:
+        case NI_Vector64_ConvertToUInt32Native:
         case NI_Vector128_ConvertToUInt32:
+        case NI_Vector128_ConvertToUInt32Native:
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_FLOAT);
 
             op1     = impSIMDPopStack();
-            retNode = gtNewSimdHWIntrinsicNode(retType, op1, NI_AdvSimd_ConvertToUInt32RoundToZero, simdBaseJitType,
-                                               simdSize);
+            retNode = gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_UINT, simdBaseJitType, simdSize);
             break;
         }
 
         case NI_Vector64_ConvertToUInt64:
+        case NI_Vector64_ConvertToUInt64Native:
         case NI_Vector128_ConvertToUInt64:
+        case NI_Vector128_ConvertToUInt64Native:
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_DOUBLE);
 
-            intrinsic = (simdSize == 8) ? NI_AdvSimd_Arm64_ConvertToUInt64RoundToZeroScalar
-                                        : NI_AdvSimd_Arm64_ConvertToUInt64RoundToZero;
-
             op1     = impSIMDPopStack();
-            retNode = gtNewSimdHWIntrinsicNode(retType, op1, intrinsic, simdBaseJitType, simdSize);
+            retNode = gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_ULONG, simdBaseJitType, simdSize);
             break;
         }
 
diff --git a/src/coreclr/jit/hwintrinsiclistarm64.h b/src/coreclr/jit/hwintrinsiclistarm64.h
index f1a48b2d28127..06feb2816de5c 100644
--- a/src/coreclr/jit/hwintrinsiclistarm64.h
+++ b/src/coreclr/jit/hwintrinsiclistarm64.h
@@ -37,10 +37,14 @@ HARDWARE_INTRINSIC(Vector64,      Ceiling,
 HARDWARE_INTRINSIC(Vector64,      ConditionalSelect,                                                 8,      3,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector64,      ConvertToDouble,                                                   8,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      ConvertToInt32,                                                    8,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector64,      ConvertToInt32Native,                                              8,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      ConvertToInt64,                                                    8,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector64,      ConvertToInt64Native,                                              8,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      ConvertToSingle,                                                   8,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      ConvertToUInt32,                                                   8,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector64,      ConvertToUInt32Native,                                             8,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      ConvertToUInt64,                                                   8,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector64,      ConvertToUInt64Native,                                             8,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      Create,                                                            8,     -1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector64,      CreateScalar,                                                      8,     -1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector64,      CreateScalarUnsafe,                                                8,      1,      true,  {INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_invalid,        INS_invalid,        INS_fmov,           INS_invalid},     HW_Category_SIMD,                  HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_SupportsContainment)
@@ -146,10 +150,14 @@ HARDWARE_INTRINSIC(Vector128,     Ceiling,
 HARDWARE_INTRINSIC(Vector128,     ConditionalSelect,                                                16,      3,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector128,     ConvertToDouble,                                                  16,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,     ConvertToInt32,                                                   16,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector128,     ConvertToInt32Native,                                             16,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,     ConvertToInt64,                                                   16,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector128,     ConvertToInt64Native,                                             16,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,     ConvertToSingle,                                                  16,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,     ConvertToUInt32,                                                  16,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector128,     ConvertToUInt32Native,                                            16,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,     ConvertToUInt64,                                                  16,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector128,     ConvertToUInt64Native,                                            16,      1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,     Create,                                                           16,     -1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector128,     CreateScalar,                                                     16,     -1,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector128,     CreateScalarUnsafe,                                               16,      1,      true,  {INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_fmov,           INS_fmov},        HW_Category_SIMD,                  HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_SupportsContainment)
diff --git a/src/coreclr/jit/hwintrinsiclistxarch.h b/src/coreclr/jit/hwintrinsiclistxarch.h
index 07bc2e4838c88..d3f7c575a8666 100644
--- a/src/coreclr/jit/hwintrinsiclistxarch.h
+++ b/src/coreclr/jit/hwintrinsiclistxarch.h
@@ -56,10 +56,14 @@ HARDWARE_INTRINSIC(Vector128,       Ceiling,
 HARDWARE_INTRINSIC(Vector128,       ConditionalSelect,                          16,             3,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector128,       ConvertToDouble,                            16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       ConvertToInt32,                             16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector128,       ConvertToInt32Native,                       16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       ConvertToInt64,                             16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector128,       ConvertToInt64Native,                       16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       ConvertToSingle,                            16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       ConvertToUInt32,                            16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector128,       ConvertToUInt32Native,                      16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       ConvertToUInt64,                            16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector128,       ConvertToUInt64Native,                      16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       Create,                                     16,            -1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector128,       CreateScalar,                               16,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector128,       CreateScalarUnsafe,                         16,             1,       true,  {INS_movd,              INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movss,              INS_movsd_simd},        HW_Category_SIMDScalar,             HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NoRMWSemantics)
@@ -162,10 +166,14 @@ HARDWARE_INTRINSIC(Vector256,       Ceiling,
 HARDWARE_INTRINSIC(Vector256,       ConditionalSelect,                          32,             3,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       ConvertToDouble,                            32,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector256,       ConvertToInt32,                             32,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
+HARDWARE_INTRINSIC(Vector256,       ConvertToInt32Native,                       32,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       ConvertToInt64,                             32,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector256,       ConvertToInt64Native,                       32,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector256,       ConvertToSingle,                            32,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       ConvertToUInt32,                            32,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector256,       ConvertToUInt32Native,                      32,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector256,       ConvertToUInt64,                            32,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector256,       ConvertToUInt64Native,                      32,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector256,       Create,                                     32,            -1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       CreateScalar,                               32,            -1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       CreateScalarUnsafe,                         32,             1,       true,  {INS_movd,              INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movss,              INS_movsd_simd},        HW_Category_SIMDScalar,             HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_AvxOnlyCompatible)
@@ -274,11 +282,15 @@ HARDWARE_INTRINSIC(Vector512,       CreateScalar,
 HARDWARE_INTRINSIC(Vector512,       CreateScalarUnsafe,                         64,             1,       true,  {INS_movd,              INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movd,               INS_movss,              INS_movsd_simd},        HW_Category_SIMDScalar,             HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen)
 HARDWARE_INTRINSIC(Vector512,       CreateSequence,                             64,             2,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector512,       ConvertToDouble,                            64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
-HARDWARE_INTRINSIC(Vector512,       ConvertToSingle,                            64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector512,       ConvertToInt32,                             64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector512,       ConvertToInt32Native,                       64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector512,       ConvertToInt64,                             64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector512,       ConvertToInt64Native,                       64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector512,       ConvertToSingle,                            64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector512,       ConvertToUInt32,                            64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector512,       ConvertToUInt32Native,                      64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector512,       ConvertToUInt64,                            64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector512,       ConvertToUInt64Native,                      64,             1,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector512,       Divide,                                     64,             2,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector512,       Equals,                                     64,             2,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector512,       EqualsAll,                                  64,             2,      false,  {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoCodeGen)
diff --git a/src/coreclr/jit/hwintrinsicxarch.cpp b/src/coreclr/jit/hwintrinsicxarch.cpp
index fc3c01e4c31d2..553e1bdf78366 100644
--- a/src/coreclr/jit/hwintrinsicxarch.cpp
+++ b/src/coreclr/jit/hwintrinsicxarch.cpp
@@ -1440,58 +1440,59 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
-        case NI_Vector128_ConvertToInt64:
-        case NI_Vector256_ConvertToInt64:
-        case NI_Vector512_ConvertToInt64:
+        case NI_Vector128_ConvertToInt32:
+        case NI_Vector256_ConvertToInt32:
+        case NI_Vector512_ConvertToInt32:
         {
             assert(sig->numArgs == 1);
-            assert(simdBaseType == TYP_DOUBLE);
-            if (IsBaselineVector512IsaSupportedOpportunistically())
+            assert(simdBaseType == TYP_FLOAT);
+
+            if (compOpportunisticallyDependsOn(InstructionSet_SSE41))
             {
                 op1     = impSIMDPopStack();
-                retNode = gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_LONG, simdBaseJitType, simdSize);
+                retNode = gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_INT, simdBaseJitType, simdSize);
             }
             break;
         }
 
-        case NI_Vector128_ConvertToUInt32:
-        case NI_Vector256_ConvertToUInt32:
-        case NI_Vector512_ConvertToUInt32:
+        case NI_Vector128_ConvertToInt32Native:
+        case NI_Vector256_ConvertToInt32Native:
+        case NI_Vector512_ConvertToInt32Native:
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_FLOAT);
-            if (IsBaselineVector512IsaSupportedOpportunistically())
-            {
-                op1     = impSIMDPopStack();
-                retNode = gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_UINT, simdBaseJitType, simdSize);
-            }
+
+            op1     = impSIMDPopStack();
+            retNode = gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_INT, simdBaseJitType, simdSize);
             break;
         }
 
-        case NI_Vector128_ConvertToUInt64:
-        case NI_Vector256_ConvertToUInt64:
-        case NI_Vector512_ConvertToUInt64:
+        case NI_Vector128_ConvertToInt64:
+        case NI_Vector256_ConvertToInt64:
+        case NI_Vector512_ConvertToInt64:
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_DOUBLE);
+
             if (IsBaselineVector512IsaSupportedOpportunistically())
             {
                 op1     = impSIMDPopStack();
-                retNode = gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_ULONG, simdBaseJitType, simdSize);
+                retNode = gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_LONG, simdBaseJitType, simdSize);
             }
             break;
         }
 
-        case NI_Vector128_ConvertToInt32:
-        case NI_Vector256_ConvertToInt32:
-        case NI_Vector512_ConvertToInt32:
+        case NI_Vector128_ConvertToInt64Native:
+        case NI_Vector256_ConvertToInt64Native:
+        case NI_Vector512_ConvertToInt64Native:
         {
             assert(sig->numArgs == 1);
-            assert(simdBaseType == TYP_FLOAT);
-            if (compOpportunisticallyDependsOn(InstructionSet_SSE41))
+            assert(simdBaseType == TYP_DOUBLE);
+
+            if (IsBaselineVector512IsaSupportedOpportunistically())
             {
                 op1     = impSIMDPopStack();
-                retNode = gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_INT, simdBaseJitType, simdSize);
+                retNode = gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_LONG, simdBaseJitType, simdSize);
             }
             break;
         }
@@ -1545,6 +1546,65 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector128_ConvertToUInt32:
+        case NI_Vector256_ConvertToUInt32:
+        case NI_Vector512_ConvertToUInt32:
+        {
+            assert(sig->numArgs == 1);
+            assert(simdBaseType == TYP_FLOAT);
+
+            if (IsBaselineVector512IsaSupportedOpportunistically())
+            {
+                op1     = impSIMDPopStack();
+                retNode = gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_UINT, simdBaseJitType, simdSize);
+            }
+            break;
+        }
+
+        case NI_Vector128_ConvertToUInt32Native:
+        case NI_Vector256_ConvertToUInt32Native:
+        case NI_Vector512_ConvertToUInt32Native:
+        {
+            assert(sig->numArgs == 1);
+            assert(simdBaseType == TYP_FLOAT);
+
+            if (IsBaselineVector512IsaSupportedOpportunistically())
+            {
+                op1     = impSIMDPopStack();
+                retNode = gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_UINT, simdBaseJitType, simdSize);
+            }
+            break;
+        }
+
+        case NI_Vector128_ConvertToUInt64:
+        case NI_Vector256_ConvertToUInt64:
+        case NI_Vector512_ConvertToUInt64:
+        {
+            assert(sig->numArgs == 1);
+            assert(simdBaseType == TYP_DOUBLE);
+            if (IsBaselineVector512IsaSupportedOpportunistically())
+            {
+                op1     = impSIMDPopStack();
+                retNode = gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_ULONG, simdBaseJitType, simdSize);
+            }
+            break;
+        }
+
+        case NI_Vector128_ConvertToUInt64Native:
+        case NI_Vector256_ConvertToUInt64Native:
+        case NI_Vector512_ConvertToUInt64Native:
+        {
+            assert(sig->numArgs == 1);
+            assert(simdBaseType == TYP_DOUBLE);
+
+            if (IsBaselineVector512IsaSupportedOpportunistically())
+            {
+                op1     = impSIMDPopStack();
+                retNode = gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_ULONG, simdBaseJitType, simdSize);
+            }
+            break;
+        }
+
         case NI_Vector128_Create:
         case NI_Vector256_Create:
         case NI_Vector512_Create:
diff --git a/src/coreclr/jit/importercalls.cpp b/src/coreclr/jit/importercalls.cpp
index 66769f037e282..e953ea4f2d045 100644
--- a/src/coreclr/jit/importercalls.cpp
+++ b/src/coreclr/jit/importercalls.cpp
@@ -5145,12 +5145,16 @@ GenTree* Compiler::impPrimitiveNamedIntrinsic(NamedIntrinsic        intrinsic,
     assert(sig->sigInst.classInstCount == 0);
 
     var_types retType = JITtype2varType(sig->retType);
-    assert(varTypeIsArithmetic(retType));
+
+    if (!varTypeIsArithmetic(retType))
+    {
+        assert((intrinsic == NI_PRIMITIVE_ConvertToInteger) || (intrinsic == NI_PRIMITIVE_ConvertToIntegerNative));
+        return nullptr;
+    }
 
     NamedIntrinsic hwintrinsic = NI_Illegal;
 
     CORINFO_ARG_LIST_HANDLE args = sig->args;
-
     assert((sig->numArgs == 1) || (sig->numArgs == 2));
 
     CORINFO_CLASS_HANDLE op1ClsHnd;
@@ -5161,6 +5165,113 @@ GenTree* Compiler::impPrimitiveNamedIntrinsic(NamedIntrinsic        intrinsic,
 
     switch (intrinsic)
     {
+        case NI_PRIMITIVE_ConvertToInteger:
+        case NI_PRIMITIVE_ConvertToIntegerNative:
+        {
+            assert(sig->sigInst.methInstCount == 1);
+            assert(varTypeIsFloating(baseType));
+
+            var_types tgtType = JitType2PreciseVarType(sig->retType);
+            retType           = genActualType(retType);
+            bool      uns     = varTypeIsUnsigned(tgtType) && !varTypeIsSmall(tgtType);
+
+            GenTree* res      = nullptr;
+            GenTree*  op1     = nullptr;
+
+#if defined(TARGET_XARCH) && defined(FEATURE_HW_INTRINSICS)
+            if ((intrinsic == NI_PRIMITIVE_ConvertToIntegerNative) && IsBaselineSimdIsaSupported())
+            {
+                NamedIntrinsic hwIntrinsicId = NI_Illegal;
+
+                if (retType == TYP_INT)
+                {
+                    if (baseType == TYP_FLOAT)
+                    {
+                        if (!uns)
+                        {
+                            hwIntrinsicId = NI_SSE_ConvertToInt32WithTruncation;
+                        }
+                        else if (IsBaselineVector512IsaSupportedOpportunistically())
+                        {
+                            hwIntrinsicId = NI_AVX512F_ConvertToUInt32WithTruncation;
+                        }
+                    }
+                    else
+                    {
+                        assert(baseType == TYP_DOUBLE);
+
+                        if (!uns)
+                        {
+                            hwIntrinsicId = NI_SSE2_ConvertToInt32WithTruncation;
+                        }
+                        else if (IsBaselineVector512IsaSupportedOpportunistically())
+                        {
+                            hwIntrinsicId = NI_AVX512F_ConvertToUInt32WithTruncation;
+                        }
+                    }
+                }
+#if defined(TARGET_AMD64)
+                else
+                {
+                    assert(retType == TYP_LONG);
+
+                    if (baseType == TYP_FLOAT)
+                    {
+                        if (!uns)
+                        {
+                            hwIntrinsicId = NI_SSE_X64_ConvertToInt64WithTruncation;
+                        }
+                        else if (IsBaselineVector512IsaSupportedOpportunistically())
+                        {
+                            hwIntrinsicId = NI_AVX512F_X64_ConvertToUInt64WithTruncation;
+                        }
+                    }
+                    else
+                    {
+                        assert(baseType == TYP_DOUBLE);
+
+                        if (!uns)
+                        {
+                            hwIntrinsicId = NI_SSE2_X64_ConvertToInt64WithTruncation;
+                        }
+                        else if (IsBaselineVector512IsaSupportedOpportunistically())
+                        {
+                            hwIntrinsicId = NI_AVX512F_X64_ConvertToUInt64WithTruncation;
+                        }
+                    }
+                }
+#endif // TARGET_AMD64
+
+                if (hwIntrinsicId != NI_Illegal)
+                {
+                    op1 = impPopStack().val;
+                    res = gtNewSimdHWIntrinsicNode(retType, op1, hwIntrinsicId, baseJitType, 16);
+
+                    if (varTypeIsSmall(tgtType))
+                    {
+                        res = gtNewCastNode(TYP_INT, res, /* uns */ false, tgtType);
+                    }
+                    return res;
+                }
+            }
+#endif // TARGET_XARCH && FEATURE_HW_INTRINSICS
+
+            op1 = impPopStack().val;
+
+            if (varTypeIsSmall(tgtType))
+            {
+                res = gtNewCastNodeL(retType, op1, /* uns */ false, retType);
+                res = gtFoldExpr(res);
+                res = gtNewCastNode(TYP_INT, res, /* uns */ false, tgtType);
+            }
+            else
+            {
+                res = gtNewCastNodeL(retType, op1, /* uns */ false, tgtType);
+            }
+
+            return gtFoldExpr(res);
+        }
+
         case NI_PRIMITIVE_Crc32C:
         {
             assert(sig->numArgs == 2);
@@ -10048,6 +10159,19 @@ NamedIntrinsic Compiler::lookupPrimitiveFloatNamedIntrinsic(CORINFO_METHOD_HANDL
             {
                 result = NI_System_Math_Ceiling;
             }
+            else if (strncmp(methodName, "ConvertToInteger", 16) == 0)
+            {
+                methodName += 16;
+
+                if (methodName[0] == '\0')
+                {
+                    result = NI_PRIMITIVE_ConvertToInteger;
+                }
+                else if (strcmp(methodName, "Native") == 0)
+                {
+                    result = NI_PRIMITIVE_ConvertToIntegerNative;
+                }
+            }
             else if (strncmp(methodName, "Cos", 3) == 0)
             {
                 methodName += 3;
diff --git a/src/coreclr/jit/namedintrinsiclist.h b/src/coreclr/jit/namedintrinsiclist.h
index b3eb292677d80..67eec1059e82e 100644
--- a/src/coreclr/jit/namedintrinsiclist.h
+++ b/src/coreclr/jit/namedintrinsiclist.h
@@ -227,6 +227,8 @@ enum NamedIntrinsic : unsigned short
 
     NI_PRIMITIVE_START,
 
+    NI_PRIMITIVE_ConvertToInteger,
+    NI_PRIMITIVE_ConvertToIntegerNative,
     NI_PRIMITIVE_Crc32C,
     NI_PRIMITIVE_LeadingZeroCount,
     NI_PRIMITIVE_Log2,
diff --git a/src/coreclr/jit/simdashwintrinsic.cpp b/src/coreclr/jit/simdashwintrinsic.cpp
index 9ffd3b7b011d5..c9b227440d4e5 100644
--- a/src/coreclr/jit/simdashwintrinsic.cpp
+++ b/src/coreclr/jit/simdashwintrinsic.cpp
@@ -523,20 +523,23 @@ GenTree* Compiler::impSimdAsHWIntrinsicSpecial(NamedIntrinsic       intrinsic,
             return nullptr;
         }
 
-        case NI_VectorT_ConvertToInt64:
-        case NI_VectorT_ConvertToUInt32:
-        case NI_VectorT_ConvertToUInt64:
+        case NI_VectorT_ConvertToInt32:
         {
-            if (IsBaselineVector512IsaSupportedOpportunistically())
+            if (compOpportunisticallyDependsOn(InstructionSet_SSE41))
             {
                 break;
             }
             return nullptr;
         }
 
-        case NI_VectorT_ConvertToInt32:
+        case NI_VectorT_ConvertToInt64:
+        case NI_VectorT_ConvertToInt64Native:
+        case NI_VectorT_ConvertToUInt32:
+        case NI_VectorT_ConvertToUInt32Native:
+        case NI_VectorT_ConvertToUInt64:
+        case NI_VectorT_ConvertToUInt64Native:
         {
-            if (compOpportunisticallyDependsOn(InstructionSet_SSE41))
+            if (IsBaselineVector512IsaSupportedOpportunistically())
             {
                 break;
             }
@@ -1175,34 +1178,6 @@ GenTree* Compiler::impSimdAsHWIntrinsicSpecial(NamedIntrinsic       intrinsic,
                 }
 
 #if defined(TARGET_XARCH)
-
-                case NI_VectorT_ConvertToInt64:
-                {
-                    assert(sig->numArgs == 1);
-                    assert(simdBaseType == TYP_DOUBLE);
-                    return gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_LONG, simdBaseJitType, simdSize);
-                }
-
-                case NI_VectorT_ConvertToUInt32:
-                {
-                    assert(sig->numArgs == 1);
-                    assert(simdBaseType == TYP_FLOAT);
-                    return gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_UINT, simdBaseJitType, simdSize);
-                }
-
-                case NI_VectorT_ConvertToUInt64:
-                {
-                    assert(sig->numArgs == 1);
-                    assert(simdBaseType == TYP_DOUBLE);
-                    return gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_ULONG, simdBaseJitType, simdSize);
-                }
-
-                case NI_VectorT_ConvertToInt32:
-                {
-                    assert(simdBaseType == TYP_FLOAT);
-                    return gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_INT, simdBaseJitType, simdSize);
-                }
-
                 case NI_VectorT_ConvertToDouble:
                 {
                     assert(sig->numArgs == 1);
@@ -1273,43 +1248,71 @@ GenTree* Compiler::impSimdAsHWIntrinsicSpecial(NamedIntrinsic       intrinsic,
                                                     simdSize);
                 }
 
+                case NI_VectorT_ConvertToSingle:
+                {
+                    assert((simdBaseType == TYP_INT) || (simdBaseType == TYP_UINT));
+                    return gtNewSimdHWIntrinsicNode(retType, op1, NI_AdvSimd_ConvertToSingle, simdBaseJitType,
+                                                    simdSize);
+                }
+#else
+#error Unsupported platform
+#endif // !TARGET_XARCH && !TARGET_ARM64
+
                 case NI_VectorT_ConvertToInt32:
                 {
+                    assert(sig->numArgs == 1);
                     assert(simdBaseType == TYP_FLOAT);
-                    return gtNewSimdHWIntrinsicNode(retType, op1, NI_AdvSimd_ConvertToInt32RoundToZero, simdBaseJitType,
-                                                    simdSize);
+                    return gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_INT, simdBaseJitType, simdSize);
+                }
+
+                case NI_VectorT_ConvertToInt32Native:
+                {
+                    assert(sig->numArgs == 1);
+                    assert(simdBaseType == TYP_FLOAT);
+                    return gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_INT, simdBaseJitType, simdSize);
                 }
 
                 case NI_VectorT_ConvertToInt64:
                 {
+                    assert(sig->numArgs == 1);
                     assert(simdBaseType == TYP_DOUBLE);
-                    return gtNewSimdHWIntrinsicNode(retType, op1, NI_AdvSimd_Arm64_ConvertToInt64RoundToZero,
-                                                    simdBaseJitType, simdSize);
+                    return gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_LONG, simdBaseJitType, simdSize);
                 }
 
-                case NI_VectorT_ConvertToSingle:
+                case NI_VectorT_ConvertToInt64Native:
                 {
-                    assert((simdBaseType == TYP_INT) || (simdBaseType == TYP_UINT));
-                    return gtNewSimdHWIntrinsicNode(retType, op1, NI_AdvSimd_ConvertToSingle, simdBaseJitType,
-                                                    simdSize);
+                    assert(sig->numArgs == 1);
+                    assert(simdBaseType == TYP_DOUBLE);
+                    return gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_LONG, simdBaseJitType, simdSize);
                 }
 
                 case NI_VectorT_ConvertToUInt32:
                 {
+                    assert(sig->numArgs == 1);
+                    assert(simdBaseType == TYP_FLOAT);
+                    return gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_UINT, simdBaseJitType, simdSize);
+                }
+
+                case NI_VectorT_ConvertToUInt32Native:
+                {
+                    assert(sig->numArgs == 1);
                     assert(simdBaseType == TYP_FLOAT);
-                    return gtNewSimdHWIntrinsicNode(retType, op1, NI_AdvSimd_ConvertToUInt32RoundToZero,
-                                                    simdBaseJitType, simdSize);
+                    return gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_UINT, simdBaseJitType, simdSize);
                 }
 
                 case NI_VectorT_ConvertToUInt64:
                 {
+                    assert(sig->numArgs == 1);
                     assert(simdBaseType == TYP_DOUBLE);
-                    return gtNewSimdHWIntrinsicNode(retType, op1, NI_AdvSimd_Arm64_ConvertToUInt64RoundToZero,
-                                                    simdBaseJitType, simdSize);
+                    return gtNewSimdCvtNode(retType, op1, CORINFO_TYPE_ULONG, simdBaseJitType, simdSize);
+                }
+
+                case NI_VectorT_ConvertToUInt64Native:
+                {
+                    assert(sig->numArgs == 1);
+                    assert(simdBaseType == TYP_DOUBLE);
+                    return gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_ULONG, simdBaseJitType, simdSize);
                 }
-#else
-#error Unsupported platform
-#endif // !TARGET_XARCH && !TARGET_ARM64
 
                 default:
                 {
diff --git a/src/coreclr/jit/simdashwintrinsiclistarm64.h b/src/coreclr/jit/simdashwintrinsiclistarm64.h
index cb8d702be5e71..911306e712409 100644
--- a/src/coreclr/jit/simdashwintrinsiclistarm64.h
+++ b/src/coreclr/jit/simdashwintrinsiclistarm64.h
@@ -224,10 +224,14 @@ SIMD_AS_HWINTRINSIC_ID(VectorT,     Ceiling,
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConditionalSelect,                                      3,         {NI_VectorT_ConditionalSelect,                  NI_VectorT_ConditionalSelect,                   NI_VectorT_ConditionalSelect,                   NI_VectorT_ConditionalSelect,                   NI_VectorT_ConditionalSelect,                   NI_VectorT_ConditionalSelect,                   NI_VectorT_ConditionalSelect,                   NI_VectorT_ConditionalSelect,                   NI_VectorT_ConditionalSelect,                   NI_VectorT_ConditionalSelect},                  SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToDouble,                                        1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_ConvertToDouble,                     NI_VectorT_ConvertToDouble,                     NI_Illegal,                                     NI_Illegal},                                    SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToInt32,                                         1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_ConvertToInt32,                      NI_Illegal},                                    SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToInt32Native,                                   1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_ConvertToInt32Native,                NI_Illegal},                                    SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToInt64,                                         1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_ConvertToInt64},                     SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToInt64Native,                                   1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_ConvertToInt64Native},               SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToSingle,                                        1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_ConvertToSingle,                     NI_VectorT_ConvertToSingle,                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal},                                    SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToUInt32,                                        1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_ConvertToUInt32,                     NI_Illegal},                                    SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToUInt32Native,                                  1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_ConvertToUInt32Native,               NI_Illegal},                                    SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToUInt64,                                        1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_ConvertToUInt64},                    SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToUInt64Native,                                  1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_ConvertToUInt64Native},              SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_NM(VectorT,     CreateBroadcast,            ".ctor",                    2,         {NI_VectorT_CreateBroadcast,                    NI_VectorT_CreateBroadcast,                     NI_VectorT_CreateBroadcast,                     NI_VectorT_CreateBroadcast,                     NI_VectorT_CreateBroadcast,                     NI_VectorT_CreateBroadcast,                     NI_VectorT_CreateBroadcast,                     NI_VectorT_CreateBroadcast,                     NI_VectorT_CreateBroadcast,                     NI_VectorT_CreateBroadcast},                    SimdAsHWIntrinsicFlag::InstanceMethod | SimdAsHWIntrinsicFlag::SpillSideEffectsOp1)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     CreateSequence,                                         2,         {NI_VectorT_CreateSequence,                     NI_VectorT_CreateSequence,                      NI_VectorT_CreateSequence,                      NI_VectorT_CreateSequence,                      NI_VectorT_CreateSequence,                      NI_VectorT_CreateSequence,                      NI_VectorT_CreateSequence,                      NI_VectorT_CreateSequence,                      NI_VectorT_CreateSequence,                      NI_VectorT_CreateSequence},                     SimdAsHWIntrinsicFlag::SpillSideEffectsOp1)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     Divide,                                                 2,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_VectorT_Divide,                              NI_VectorT_Divide},                             SimdAsHWIntrinsicFlag::None)
diff --git a/src/coreclr/jit/simdashwintrinsiclistxarch.h b/src/coreclr/jit/simdashwintrinsiclistxarch.h
index 5cf07eff0c84a..dd1d6374bc248 100644
--- a/src/coreclr/jit/simdashwintrinsiclistxarch.h
+++ b/src/coreclr/jit/simdashwintrinsiclistxarch.h
@@ -224,10 +224,14 @@ SIMD_AS_HWINTRINSIC_ID(VectorT,     Ceiling,
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConditionalSelect,                                      3,         {NI_VectorT_ConditionalSelect,              NI_VectorT_ConditionalSelect,               NI_VectorT_ConditionalSelect,               NI_VectorT_ConditionalSelect,               NI_VectorT_ConditionalSelect,               NI_VectorT_ConditionalSelect,               NI_VectorT_ConditionalSelect,               NI_VectorT_ConditionalSelect,               NI_VectorT_ConditionalSelect,               NI_VectorT_ConditionalSelect},              SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToDouble,                                        1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_ConvertToDouble,                 NI_VectorT_ConvertToDouble,                 NI_Illegal,                                 NI_Illegal},                                SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToInt32,                                         1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_ConvertToInt32,                  NI_Illegal},                                SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToInt32Native,                                   1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_ConvertToInt32Native,            NI_Illegal},                                SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToInt64,                                         1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_ConvertToInt64},                 SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToInt64Native,                                   1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_ConvertToInt64Native},           SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToSingle,                                        1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_ConvertToSingle,                 NI_VectorT_ConvertToSingle,                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal},                                SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToUInt32,                                        1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_ConvertToUInt32,                 NI_Illegal},                                SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToUInt32Native,                                  1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_ConvertToUInt32Native,           NI_Illegal},                                SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToUInt64,                                        1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_ConvertToUInt64},                SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT,     ConvertToUInt64Native,                                  1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_ConvertToUInt64Native},          SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_NM(VectorT,     CreateBroadcast,            ".ctor",                    2,         {NI_VectorT_CreateBroadcast,                NI_VectorT_CreateBroadcast,                 NI_VectorT_CreateBroadcast,                 NI_VectorT_CreateBroadcast,                 NI_VectorT_CreateBroadcast,                 NI_VectorT_CreateBroadcast,                 NI_VectorT_CreateBroadcast,                 NI_VectorT_CreateBroadcast,                 NI_VectorT_CreateBroadcast,                 NI_VectorT_CreateBroadcast},                SimdAsHWIntrinsicFlag::InstanceMethod | SimdAsHWIntrinsicFlag::SpillSideEffectsOp1)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     CreateSequence,                                         2,         {NI_VectorT_CreateSequence,                 NI_VectorT_CreateSequence,                  NI_VectorT_CreateSequence,                  NI_VectorT_CreateSequence,                  NI_VectorT_CreateSequence,                  NI_VectorT_CreateSequence,                  NI_VectorT_CreateSequence,                  NI_VectorT_CreateSequence,                  NI_VectorT_CreateSequence,                  NI_VectorT_CreateSequence},                 SimdAsHWIntrinsicFlag::SpillSideEffectsOp1)
 SIMD_AS_HWINTRINSIC_ID(VectorT,     Divide,                                                 2,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_VectorT_Divide,                          NI_VectorT_Divide},                         SimdAsHWIntrinsicFlag::None)
diff --git a/src/libraries/Common/tests/System/GenericMathHelpers.cs b/src/libraries/Common/tests/System/GenericMathHelpers.cs
index 277580dc5920d..a02f8a4e162a6 100644
--- a/src/libraries/Common/tests/System/GenericMathHelpers.cs
+++ b/src/libraries/Common/tests/System/GenericMathHelpers.cs
@@ -151,6 +151,12 @@ public static class FloatingPointHelper<TSelf>
     {
         public static TSelf Ceiling(TSelf x) => TSelf.Ceiling(x);
 
+        public static TInteger ConvertToInteger<TInteger>(TSelf x)
+            where TInteger : IBinaryInteger<TInteger> => TSelf.ConvertToInteger<TInteger>(x);
+
+        public static TInteger ConvertToIntegerNative<TInteger>(TSelf x)
+            where TInteger : IBinaryInteger<TInteger> => TSelf.ConvertToIntegerNative<TInteger>(x);
+
         public static TSelf Floor(TSelf x) => TSelf.Floor(x);
 
         public static TSelf Round(TSelf x) => TSelf.Round(x);
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
index 0ebed660f3368..345da5e4553b8 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
@@ -5,6 +5,7 @@
 using System.Numerics;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
 using Xunit;
 
 namespace System.Runtime.Intrinsics.Tests.Vectors
@@ -4872,5 +4873,100 @@ public void Log2SingleTest(float value, float expectedResult, float variance)
             Vector128<float> actualResult = Vector128.Log2(Vector128.Create(value));
             AssertEqual(Vector128.Create(expectedResult), actualResult, Vector128.Create(variance));
         }
+
+        [Fact]
+        public void ConvertToInt32Test()
+        {
+            Assert.Equal(Vector128.Create(int.MinValue), Vector128.ConvertToInt32(Vector128.Create(float.MinValue)));
+            Assert.Equal(Vector128.Create(2), Vector128.ConvertToInt32(Vector128.Create(2.6f)));
+            Assert.Equal(Vector128.Create(int.MaxValue), Vector128.ConvertToInt32(Vector128.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToInt32NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Sse2.IsSupported)
+            {
+                Assert.Equal(Vector128.Create(int.MinValue), Vector128.ConvertToInt32Native(Vector128.Create(float.MaxValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector128.Create(int.MaxValue), Vector128.ConvertToInt32Native(Vector128.Create(float.MaxValue)));
+            }
+            Assert.Equal(Vector128.Create(int.MinValue), Vector128.ConvertToInt32Native(Vector128.Create(float.MinValue)));
+            Assert.Equal(Vector128.Create(2), Vector128.ConvertToInt32Native(Vector128.Create(2.6f)));
+        }
+
+        [Fact]
+        public void ConvertToInt64Test()
+        {
+            Assert.Equal(Vector128.Create(long.MinValue), Vector128.ConvertToInt64(Vector128.Create(double.MinValue)));
+            Assert.Equal(Vector128.Create(2L), Vector128.ConvertToInt64(Vector128.Create(2.6)));
+            Assert.Equal(Vector128.Create(long.MaxValue), Vector128.ConvertToInt64(Vector128.Create(double.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToInt64NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
+            {
+                Assert.Equal(Vector128.Create(long.MinValue), Vector128.ConvertToInt64Native(Vector128.Create(double.MaxValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector128.Create(long.MaxValue), Vector128.ConvertToInt64Native(Vector128.Create(double.MaxValue)));
+            }
+
+            Assert.Equal(Vector128.Create(long.MinValue), Vector128.ConvertToInt64Native(Vector128.Create(double.MinValue)));
+            Assert.Equal(Vector128.Create(2L), Vector128.ConvertToInt64Native(Vector128.Create(2.6)));
+        }
+
+        [Fact]
+        public void ConvertToUInt32Test()
+        {
+            Assert.Equal(Vector128.Create(uint.MinValue), Vector128.ConvertToUInt32(Vector128.Create(float.MinValue)));
+            Assert.Equal(Vector128.Create(2u), Vector128.ConvertToUInt32(Vector128.Create(2.6f)));
+            Assert.Equal(Vector128.Create(uint.MaxValue), Vector128.ConvertToUInt32(Vector128.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt32NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Avx512F.VL.IsSupported)
+            {
+                Assert.Equal(Vector128.Create(uint.MaxValue), Vector128.ConvertToUInt32Native(Vector128.Create(float.MinValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector128.Create(uint.MinValue), Vector128.ConvertToUInt32Native(Vector128.Create(float.MinValue)));
+            }
+
+            Assert.Equal(Vector128.Create(2u), Vector128.ConvertToUInt32Native(Vector128.Create(2.6f)));
+            Assert.Equal(Vector128.Create(uint.MaxValue), Vector128.ConvertToUInt32Native(Vector128.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt64Test()
+        {
+            Assert.Equal(Vector128.Create(ulong.MinValue), Vector128.ConvertToUInt64(Vector128.Create(double.MinValue)));
+            Assert.Equal(Vector128.Create(2UL), Vector128.ConvertToUInt64(Vector128.Create(2.6)));
+            Assert.Equal(Vector128.Create(ulong.MaxValue), Vector128.ConvertToUInt64(Vector128.Create(double.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt64NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
+            {
+                Assert.Equal(Vector128.Create(ulong.MaxValue), Vector128.ConvertToUInt64Native(Vector128.Create(double.MinValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector128.Create(ulong.MinValue), Vector128.ConvertToUInt64Native(Vector128.Create(double.MinValue)));
+            }
+
+            Assert.Equal(Vector128.Create(2UL), Vector128.ConvertToUInt64Native(Vector128.Create(2.6)));
+            Assert.Equal(Vector128.Create(ulong.MaxValue), Vector128.ConvertToUInt64Native(Vector128.Create(double.MaxValue)));
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
index d658ca08b17b3..7f373a45e790f 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
 using Xunit;
 
 namespace System.Runtime.Intrinsics.Tests.Vectors
@@ -5887,5 +5888,100 @@ public void Log2SingleTest(float value, float expectedResult, float variance)
             Vector256<float> actualResult = Vector256.Log2(Vector256.Create(value));
             AssertEqual(Vector256.Create(expectedResult), actualResult, Vector256.Create(variance));
         }
+
+        [Fact]
+        public void ConvertToInt32Test()
+        {
+            Assert.Equal(Vector256.Create(int.MinValue), Vector256.ConvertToInt32(Vector256.Create(float.MinValue)));
+            Assert.Equal(Vector256.Create(2), Vector256.ConvertToInt32(Vector256.Create(2.6f)));
+            Assert.Equal(Vector256.Create(int.MaxValue), Vector256.ConvertToInt32(Vector256.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToInt32NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Sse2.IsSupported)
+            {
+                Assert.Equal(Vector256.Create(int.MinValue), Vector256.ConvertToInt32Native(Vector256.Create(float.MaxValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector256.Create(int.MaxValue), Vector256.ConvertToInt32Native(Vector256.Create(float.MaxValue)));
+            }
+            Assert.Equal(Vector256.Create(int.MinValue), Vector256.ConvertToInt32Native(Vector256.Create(float.MinValue)));
+            Assert.Equal(Vector256.Create(2), Vector256.ConvertToInt32Native(Vector256.Create(2.6f)));
+        }
+
+        [Fact]
+        public void ConvertToInt64Test()
+        {
+            Assert.Equal(Vector256.Create(long.MinValue), Vector256.ConvertToInt64(Vector256.Create(double.MinValue)));
+            Assert.Equal(Vector256.Create(2L), Vector256.ConvertToInt64(Vector256.Create(2.6)));
+            Assert.Equal(Vector256.Create(long.MaxValue), Vector256.ConvertToInt64(Vector256.Create(double.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToInt64NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
+            {
+                Assert.Equal(Vector256.Create(long.MinValue), Vector256.ConvertToInt64Native(Vector256.Create(double.MaxValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector256.Create(long.MaxValue), Vector256.ConvertToInt64Native(Vector256.Create(double.MaxValue)));
+            }
+
+            Assert.Equal(Vector256.Create(long.MinValue), Vector256.ConvertToInt64Native(Vector256.Create(double.MinValue)));
+            Assert.Equal(Vector256.Create(2L), Vector256.ConvertToInt64Native(Vector256.Create(2.6)));
+        }
+
+        [Fact]
+        public void ConvertToUInt32Test()
+        {
+            Assert.Equal(Vector256.Create(uint.MinValue), Vector256.ConvertToUInt32(Vector256.Create(float.MinValue)));
+            Assert.Equal(Vector256.Create(2u), Vector256.ConvertToUInt32(Vector256.Create(2.6f)));
+            Assert.Equal(Vector256.Create(uint.MaxValue), Vector256.ConvertToUInt32(Vector256.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt32NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Avx512F.VL.IsSupported)
+            {
+                Assert.Equal(Vector256.Create(uint.MaxValue), Vector256.ConvertToUInt32Native(Vector256.Create(float.MinValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector256.Create(uint.MinValue), Vector256.ConvertToUInt32Native(Vector256.Create(float.MinValue)));
+            }
+
+            Assert.Equal(Vector256.Create(2u), Vector256.ConvertToUInt32Native(Vector256.Create(2.6f)));
+            Assert.Equal(Vector256.Create(uint.MaxValue), Vector256.ConvertToUInt32Native(Vector256.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt64Test()
+        {
+            Assert.Equal(Vector256.Create(ulong.MinValue), Vector256.ConvertToUInt64(Vector256.Create(double.MinValue)));
+            Assert.Equal(Vector256.Create(2UL), Vector256.ConvertToUInt64(Vector256.Create(2.6)));
+            Assert.Equal(Vector256.Create(ulong.MaxValue), Vector256.ConvertToUInt64(Vector256.Create(double.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt64NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
+            {
+                Assert.Equal(Vector256.Create(ulong.MaxValue), Vector256.ConvertToUInt64Native(Vector256.Create(double.MinValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector256.Create(ulong.MinValue), Vector256.ConvertToUInt64Native(Vector256.Create(double.MinValue)));
+            }
+
+            Assert.Equal(Vector256.Create(2UL), Vector256.ConvertToUInt64Native(Vector256.Create(2.6)));
+            Assert.Equal(Vector256.Create(ulong.MaxValue), Vector256.ConvertToUInt64Native(Vector256.Create(double.MaxValue)));
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
index 4b4f9e2d4692a..b7d0427a78df5 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
 using Xunit;
 
 namespace System.Runtime.Intrinsics.Tests.Vectors
@@ -5320,5 +5321,100 @@ public void Log2SingleTest(float value, float expectedResult, float variance)
             Vector512<float> actualResult = Vector512.Log2(Vector512.Create(value));
             AssertEqual(Vector512.Create(expectedResult), actualResult, Vector512.Create(variance));
         }
+
+        [Fact]
+        public void ConvertToInt32Test()
+        {
+            Assert.Equal(Vector512.Create(int.MinValue), Vector512.ConvertToInt32(Vector512.Create(float.MinValue)));
+            Assert.Equal(Vector512.Create(2), Vector512.ConvertToInt32(Vector512.Create(2.6f)));
+            Assert.Equal(Vector512.Create(int.MaxValue), Vector512.ConvertToInt32(Vector512.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToInt32NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Sse2.IsSupported)
+            {
+                Assert.Equal(Vector512.Create(int.MinValue), Vector512.ConvertToInt32Native(Vector512.Create(float.MaxValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector512.Create(int.MaxValue), Vector512.ConvertToInt32Native(Vector512.Create(float.MaxValue)));
+            }
+            Assert.Equal(Vector512.Create(int.MinValue), Vector512.ConvertToInt32Native(Vector512.Create(float.MinValue)));
+            Assert.Equal(Vector512.Create(2), Vector512.ConvertToInt32Native(Vector512.Create(2.6f)));
+        }
+
+        [Fact]
+        public void ConvertToInt64Test()
+        {
+            Assert.Equal(Vector512.Create(long.MinValue), Vector512.ConvertToInt64(Vector512.Create(double.MinValue)));
+            Assert.Equal(Vector512.Create(2L), Vector512.ConvertToInt64(Vector512.Create(2.6)));
+            Assert.Equal(Vector512.Create(long.MaxValue), Vector512.ConvertToInt64(Vector512.Create(double.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToInt64NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
+            {
+                Assert.Equal(Vector512.Create(long.MinValue), Vector512.ConvertToInt64Native(Vector512.Create(double.MaxValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector512.Create(long.MaxValue), Vector512.ConvertToInt64Native(Vector512.Create(double.MaxValue)));
+            }
+
+            Assert.Equal(Vector512.Create(long.MinValue), Vector512.ConvertToInt64Native(Vector512.Create(double.MinValue)));
+            Assert.Equal(Vector512.Create(2L), Vector512.ConvertToInt64Native(Vector512.Create(2.6)));
+        }
+
+        [Fact]
+        public void ConvertToUInt32Test()
+        {
+            Assert.Equal(Vector512.Create(uint.MinValue), Vector512.ConvertToUInt32(Vector512.Create(float.MinValue)));
+            Assert.Equal(Vector512.Create(2u), Vector512.ConvertToUInt32(Vector512.Create(2.6f)));
+            Assert.Equal(Vector512.Create(uint.MaxValue), Vector512.ConvertToUInt32(Vector512.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt32NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Avx512F.VL.IsSupported)
+            {
+                Assert.Equal(Vector512.Create(uint.MaxValue), Vector512.ConvertToUInt32Native(Vector512.Create(float.MinValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector512.Create(uint.MinValue), Vector512.ConvertToUInt32Native(Vector512.Create(float.MinValue)));
+            }
+
+            Assert.Equal(Vector512.Create(2u), Vector512.ConvertToUInt32Native(Vector512.Create(2.6f)));
+            Assert.Equal(Vector512.Create(uint.MaxValue), Vector512.ConvertToUInt32Native(Vector512.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt64Test()
+        {
+            Assert.Equal(Vector512.Create(ulong.MinValue), Vector512.ConvertToUInt64(Vector512.Create(double.MinValue)));
+            Assert.Equal(Vector512.Create(2UL), Vector512.ConvertToUInt64(Vector512.Create(2.6)));
+            Assert.Equal(Vector512.Create(ulong.MaxValue), Vector512.ConvertToUInt64(Vector512.Create(double.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt64NativeTest()
+        {
+            if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
+            {
+                Assert.Equal(Vector512.Create(ulong.MaxValue), Vector512.ConvertToUInt64Native(Vector512.Create(double.MinValue)));
+            }
+            else
+            {
+                Assert.Equal(Vector512.Create(ulong.MinValue), Vector512.ConvertToUInt64Native(Vector512.Create(double.MinValue)));
+            }
+
+            Assert.Equal(Vector512.Create(2UL), Vector512.ConvertToUInt64Native(Vector512.Create(2.6)));
+            Assert.Equal(Vector512.Create(ulong.MaxValue), Vector512.ConvertToUInt64Native(Vector512.Create(double.MaxValue)));
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
index 69f37520ad735..d974c334946b5 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
 using Xunit;
 
 namespace System.Runtime.Intrinsics.Tests.Vectors
@@ -4287,5 +4288,69 @@ public void Log2SingleTest(float value, float expectedResult, float variance)
             Vector64<float> actualResult = Vector64.Log2(Vector64.Create(value));
             AssertEqual(Vector64.Create(expectedResult), actualResult, Vector64.Create(variance));
         }
+
+        [Fact]
+        public void ConvertToInt32Test()
+        {
+            Assert.Equal(Vector64.Create(int.MinValue), Vector64.ConvertToInt32(Vector64.Create(float.MinValue)));
+            Assert.Equal(Vector64.Create(2), Vector64.ConvertToInt32(Vector64.Create(2.6f)));
+            Assert.Equal(Vector64.Create(int.MaxValue), Vector64.ConvertToInt32(Vector64.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToInt32NativeTest()
+        {
+            Assert.Equal(Vector64.Create(int.MinValue), Vector64.ConvertToInt32Native(Vector64.Create(float.MinValue)));
+            Assert.Equal(Vector64.Create(2), Vector64.ConvertToInt32Native(Vector64.Create(2.6f)));
+            Assert.Equal(Vector64.Create(int.MaxValue), Vector64.ConvertToInt32Native(Vector64.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToInt64Test()
+        {
+            Assert.Equal(Vector64.Create(long.MinValue), Vector64.ConvertToInt64(Vector64.Create(double.MinValue)));
+            Assert.Equal(Vector64.Create(2L), Vector64.ConvertToInt64(Vector64.Create(2.6)));
+            Assert.Equal(Vector64.Create(long.MaxValue), Vector64.ConvertToInt64(Vector64.Create(double.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToInt64NativeTest()
+        {
+            Assert.Equal(Vector64.Create(long.MinValue), Vector64.ConvertToInt64Native(Vector64.Create(double.MinValue)));
+            Assert.Equal(Vector64.Create(2L), Vector64.ConvertToInt64Native(Vector64.Create(2.6)));
+            Assert.Equal(Vector64.Create(long.MaxValue), Vector64.ConvertToInt64Native(Vector64.Create(double.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt32Test()
+        {
+            Assert.Equal(Vector64.Create(uint.MinValue), Vector64.ConvertToUInt32(Vector64.Create(float.MinValue)));
+            Assert.Equal(Vector64.Create(2u), Vector64.ConvertToUInt32(Vector64.Create(2.6f)));
+            Assert.Equal(Vector64.Create(uint.MaxValue), Vector64.ConvertToUInt32(Vector64.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt32NativeTest()
+        {
+            Assert.Equal(Vector64.Create(uint.MinValue), Vector64.ConvertToUInt32Native(Vector64.Create(float.MinValue)));
+            Assert.Equal(Vector64.Create(2u), Vector64.ConvertToUInt32Native(Vector64.Create(2.6f)));
+            Assert.Equal(Vector64.Create(uint.MaxValue), Vector64.ConvertToUInt32Native(Vector64.Create(float.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt64Test()
+        {
+            Assert.Equal(Vector64.Create(ulong.MinValue), Vector64.ConvertToUInt64(Vector64.Create(double.MinValue)));
+            Assert.Equal(Vector64.Create(2UL), Vector64.ConvertToUInt64(Vector64.Create(2.6)));
+            Assert.Equal(Vector64.Create(ulong.MaxValue), Vector64.ConvertToUInt64(Vector64.Create(double.MaxValue)));
+        }
+
+        [Fact]
+        public void ConvertToUInt64NativeTest()
+        {
+            Assert.Equal(Vector64.Create(ulong.MinValue), Vector64.ConvertToUInt64Native(Vector64.Create(double.MinValue)));
+            Assert.Equal(Vector64.Create(2UL), Vector64.ConvertToUInt64Native(Vector64.Create(2.6)));
+            Assert.Equal(Vector64.Create(ulong.MaxValue), Vector64.ConvertToUInt64Native(Vector64.Create(double.MaxValue)));
+        }
     }
 }
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/DoubleTests.GenericMath.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/DoubleTests.GenericMath.cs
index 05e71be7b325c..5666891611766 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/DoubleTests.GenericMath.cs
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/DoubleTests.GenericMath.cs
@@ -3,6 +3,7 @@
 
 using System.Globalization;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
 using Xunit;
 
 namespace System.Tests
@@ -356,6 +357,186 @@ public static void op_InequalityTest()
         // IFloatingPoint
         //
 
+        [Fact]
+        public static void ConvertToIntegerTest()
+        {
+            // Signed Values
+
+            Assert.Equal(0, FloatingPointHelper<double>.ConvertToInteger<short>(double.MinValue));
+            Assert.Equal(int.MinValue, FloatingPointHelper<double>.ConvertToInteger<int>(double.MinValue));
+            Assert.Equal(long.MinValue, FloatingPointHelper<double>.ConvertToInteger<long>(double.MinValue));
+            Assert.Equal(Int128.MinValue, FloatingPointHelper<double>.ConvertToInteger<Int128>(double.MinValue));
+            Assert.Equal(nint.MinValue, FloatingPointHelper<double>.ConvertToInteger<nint>(double.MinValue));
+            Assert.Equal(0, FloatingPointHelper<double>.ConvertToInteger<sbyte>(double.MinValue));
+
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToInteger<short>(2.6));
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToInteger<int>(2.6));
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToInteger<long>(2.6));
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToInteger<Int128>(2.6));
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToInteger<nint>(2.6));
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToInteger<sbyte>(2.6));
+
+            Assert.Equal(-1, FloatingPointHelper<double>.ConvertToInteger<short>(double.MaxValue));
+            Assert.Equal(int.MaxValue, FloatingPointHelper<double>.ConvertToInteger<int>(double.MaxValue));
+            Assert.Equal(long.MaxValue, FloatingPointHelper<double>.ConvertToInteger<long>(double.MaxValue));
+            Assert.Equal(Int128.MaxValue, FloatingPointHelper<double>.ConvertToInteger<Int128>(double.MaxValue));
+            Assert.Equal(nint.MaxValue, FloatingPointHelper<double>.ConvertToInteger<nint>(double.MaxValue));
+            Assert.Equal(-1, FloatingPointHelper<double>.ConvertToInteger<sbyte>(double.MaxValue));
+
+            // Unsigned Values
+
+            Assert.Equal(byte.MinValue, FloatingPointHelper<double>.ConvertToInteger<byte>(double.MinValue));
+            Assert.Equal(ushort.MinValue, FloatingPointHelper<double>.ConvertToInteger<ushort>(double.MinValue));
+            Assert.Equal(uint.MinValue, FloatingPointHelper<double>.ConvertToInteger<uint>(double.MinValue));
+            Assert.Equal(ulong.MinValue, FloatingPointHelper<double>.ConvertToInteger<ulong>(double.MinValue));
+            Assert.Equal(UInt128.MinValue, FloatingPointHelper<double>.ConvertToInteger<UInt128>(double.MinValue));
+            Assert.Equal(nuint.MinValue, FloatingPointHelper<double>.ConvertToInteger<nuint>(double.MinValue));
+
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToInteger<byte>(2.6));
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToInteger<ushort>(2.6));
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToInteger<uint>(2.6));
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToInteger<ulong>(2.6));
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToInteger<UInt128>(2.6));
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToInteger<nuint>(2.6));
+
+            Assert.Equal(byte.MaxValue, FloatingPointHelper<double>.ConvertToInteger<byte>(double.MaxValue));
+            Assert.Equal(ushort.MaxValue, FloatingPointHelper<double>.ConvertToInteger<ushort>(double.MaxValue));
+            Assert.Equal(uint.MaxValue, FloatingPointHelper<double>.ConvertToInteger<uint>(double.MaxValue));
+            Assert.Equal(ulong.MaxValue, FloatingPointHelper<double>.ConvertToInteger<ulong>(double.MaxValue));
+            Assert.Equal(UInt128.MaxValue, FloatingPointHelper<double>.ConvertToInteger<UInt128>(double.MaxValue));
+            Assert.Equal(nuint.MaxValue, FloatingPointHelper<double>.ConvertToInteger<nuint>(double.MaxValue));
+        }
+
+        [Fact]
+        public static void ConvertToIntegerNativeTest()
+        {
+            // Signed Values
+
+            if (Sse2.IsSupported)
+            {
+                // On Xarch:
+                // * Conversion to int is natively supported and returns 0x8000_0000
+                // * Conversion to long is natively supported on 64-bit and returns 0x8000_0000_0000_0000
+
+                Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<short>(double.MinValue));
+                Assert.Equal(int.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<int>(double.MinValue));
+                Assert.Equal(nint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<nint>(double.MinValue));
+                Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MinValue));
+
+                if (Environment.Is64BitProcess)
+                {
+                    Assert.Equal(long.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MinValue));
+                }
+                else
+                {
+                    Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MinValue));
+                }
+            }
+            else
+            {
+                Assert.Equal(short.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<short>(double.MinValue));
+                Assert.Equal(int.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<int>(double.MinValue));
+                Assert.Equal(long.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MinValue));
+                Assert.Equal(nint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<nint>(double.MinValue));
+                Assert.Equal(sbyte.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MinValue));
+            }
+            Assert.Equal(Int128.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<Int128>(double.MinValue));
+
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToIntegerNative<short>(2.6));
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToIntegerNative<int>(2.6));
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToIntegerNative<long>(2.6));
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToIntegerNative<Int128>(2.6));
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToIntegerNative<nint>(2.6));
+            Assert.Equal(2, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(2.6));
+
+            if (Sse2.IsSupported)
+            {
+                // On Xarch:
+                // * Conversion to int is natively supported and returns 0x8000_0000
+                // * Conversion to long is natively supported on 64-bit and returns 0x8000_0000_0000_0000
+
+                Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<short>(double.MaxValue));
+                Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MaxValue));
+
+                Assert.Equal(int.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<int>(double.MaxValue));
+                Assert.Equal(long.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MaxValue));
+                Assert.Equal(nint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<nint>(double.MaxValue));
+            }
+            else
+            {
+                Assert.Equal(short.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<short>(double.MaxValue));
+                Assert.Equal(int.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<int>(double.MaxValue));
+                Assert.Equal(long.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MaxValue));
+                Assert.Equal(nint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<nint>(double.MaxValue));
+                Assert.Equal(sbyte.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MaxValue));
+            }
+            Assert.Equal(Int128.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<Int128>(double.MaxValue));
+
+            // Unsigned Values
+
+            if (Sse2.IsSupported)
+            {
+                // On Xarch:
+                // * Conversion to uint is natively supported w/ Avx512 and returns 0xFFFF_FFFF
+                // * Conversion to ulong is natively supported on 64-bit w/ Avx512 and returns 0xFFFF_FFFF_FFFF_FFFF
+
+                if (Avx512F.IsSupported)
+                {
+                    Assert.Equal(uint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<uint>(double.MinValue));
+                    Assert.Equal(nuint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<nuint>(double.MinValue));
+                }
+                else
+                {
+                    Assert.Equal(uint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<uint>(double.MinValue));
+                    Assert.Equal(nuint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<nuint>(double.MinValue));
+                }
+
+                if (Environment.Is64BitProcess && Avx512F.IsSupported)
+                {
+                    Assert.Equal(ulong.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<ulong>(double.MinValue));
+                }
+                else
+                {
+                    Assert.Equal(ulong.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<ulong>(double.MinValue));
+                }
+            }
+            else
+            {
+                Assert.Equal(uint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<uint>(double.MinValue));
+                Assert.Equal(ulong.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<ulong>(double.MinValue));
+                Assert.Equal(nuint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<nuint>(double.MinValue));
+            }
+            Assert.Equal(byte.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<byte>(double.MinValue));
+            Assert.Equal(ushort.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<ushort>(double.MinValue));
+            Assert.Equal(UInt128.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<UInt128>(double.MinValue));
+
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToIntegerNative<byte>(2.6));
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToIntegerNative<ushort>(2.6));
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToIntegerNative<uint>(2.6));
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToIntegerNative<ulong>(2.6));
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToIntegerNative<UInt128>(2.6));
+            Assert.Equal(2u, FloatingPointHelper<double>.ConvertToIntegerNative<nuint>(2.6));
+
+            if (Sse2.IsSupported)
+            {
+                // On Xarch:
+                // * Conversion to uint is natively supported w/ Avx512 and returns 0xFFFF_FFFF
+                // * Conversion to ulong is natively supported on 64-bit w/ Avx512 and returns 0xFFFF_FFFF_FFFF_FFFF
+
+                Assert.Equal(byte.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<byte>(double.MaxValue));
+                Assert.Equal(ushort.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<ushort>(double.MaxValue));
+            }
+            else
+            {
+                Assert.Equal(byte.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<byte>(double.MaxValue));
+                Assert.Equal(nuint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<nuint>(double.MaxValue));
+            }
+            Assert.Equal(uint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<uint>(double.MaxValue));
+            Assert.Equal(ulong.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<ulong>(double.MaxValue));
+            Assert.Equal(UInt128.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<UInt128>(double.MaxValue));
+            Assert.Equal(nuint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<ulong>(double.MaxValue));
+        }
+
         [Fact]
         public static void GetExponentByteCountTest()
         {
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/SingleTests.GenericMath.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/SingleTests.GenericMath.cs
index a6637de7f7e2a..48dd4b5240058 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/SingleTests.GenericMath.cs
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/SingleTests.GenericMath.cs
@@ -3,6 +3,7 @@
 
 using System.Globalization;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
 using Xunit;
 
 namespace System.Tests
@@ -356,6 +357,189 @@ public static void op_InequalityTest()
         // IFloatingPoint
         //
 
+        [Fact]
+        public static void ConvertToIntegerTest()
+        {
+            // Signed Values
+
+            Assert.Equal(0, FloatingPointHelper<float>.ConvertToInteger<short>(float.MinValue));
+            Assert.Equal(int.MinValue, FloatingPointHelper<float>.ConvertToInteger<int>(float.MinValue));
+            Assert.Equal(long.MinValue, FloatingPointHelper<float>.ConvertToInteger<long>(float.MinValue));
+            Assert.Equal(Int128.MinValue, FloatingPointHelper<float>.ConvertToInteger<Int128>(float.MinValue));
+            Assert.Equal(nint.MinValue, FloatingPointHelper<float>.ConvertToInteger<nint>(float.MinValue));
+            Assert.Equal(0, FloatingPointHelper<float>.ConvertToInteger<sbyte>(float.MinValue));
+
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToInteger<short>(2.6f));
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToInteger<int>(2.6f));
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToInteger<long>(2.6f));
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToInteger<Int128>(2.6f));
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToInteger<nint>(2.6f));
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToInteger<sbyte>(2.6f));
+
+            Assert.Equal(-1, FloatingPointHelper<float>.ConvertToInteger<short>(float.MaxValue));
+            Assert.Equal(int.MaxValue, FloatingPointHelper<float>.ConvertToInteger<int>(float.MaxValue));
+            Assert.Equal(long.MaxValue, FloatingPointHelper<float>.ConvertToInteger<long>(float.MaxValue));
+            Assert.Equal(Int128.MaxValue, FloatingPointHelper<float>.ConvertToInteger<Int128>(float.MaxValue));
+            Assert.Equal(nint.MaxValue, FloatingPointHelper<float>.ConvertToInteger<nint>(float.MaxValue));
+            Assert.Equal(-1, FloatingPointHelper<float>.ConvertToInteger<sbyte>(float.MaxValue));
+
+            // Unsigned Values
+
+            Assert.Equal(byte.MinValue, FloatingPointHelper<float>.ConvertToInteger<byte>(float.MinValue));
+            Assert.Equal(ushort.MinValue, FloatingPointHelper<float>.ConvertToInteger<ushort>(float.MinValue));
+            Assert.Equal(uint.MinValue, FloatingPointHelper<float>.ConvertToInteger<uint>(float.MinValue));
+            Assert.Equal(ulong.MinValue, FloatingPointHelper<float>.ConvertToInteger<ulong>(float.MinValue));
+            Assert.Equal(UInt128.MinValue, FloatingPointHelper<float>.ConvertToInteger<UInt128>(float.MinValue));
+            Assert.Equal(nuint.MinValue, FloatingPointHelper<float>.ConvertToInteger<nuint>(float.MinValue));
+
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToInteger<byte>(2.6f));
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToInteger<ushort>(2.6f));
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToInteger<uint>(2.6f));
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToInteger<ulong>(2.6f));
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToInteger<UInt128>(2.6f));
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToInteger<nuint>(2.6f));
+
+            Assert.Equal(byte.MaxValue, FloatingPointHelper<float>.ConvertToInteger<byte>(float.MaxValue));
+            Assert.Equal(ushort.MaxValue, FloatingPointHelper<float>.ConvertToInteger<ushort>(float.MaxValue));
+            Assert.Equal(uint.MaxValue, FloatingPointHelper<float>.ConvertToInteger<uint>(float.MaxValue));
+            Assert.Equal(ulong.MaxValue, FloatingPointHelper<float>.ConvertToInteger<ulong>(float.MaxValue));
+            Assert.Equal(new UInt128(0xFFFF_FF00_0000_0000, 0x0000_0000_0000_0000), FloatingPointHelper<float>.ConvertToInteger<UInt128>(float.MaxValue));
+            Assert.Equal(nuint.MaxValue, FloatingPointHelper<float>.ConvertToInteger<nuint>(float.MaxValue));
+        }
+
+        [Fact]
+        public static void ConvertToIntegerNativeTest()
+        {
+            // Signed Values
+
+            if (Sse2.IsSupported)
+            {
+                // On Xarch:
+                // * Conversion to int is natively supported and returns 0x8000_0000
+                // * Conversion to long is natively supported on 64-bit and returns 0x8000_0000_0000_0000
+
+                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<short>(float.MinValue));
+                Assert.Equal(int.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<int>(float.MinValue));
+                Assert.Equal(nint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<nint>(float.MinValue));
+                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MinValue));
+
+                if (Environment.Is64BitProcess)
+                {
+                    Assert.Equal(long.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MinValue));
+                }
+                else
+                {
+                    Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MinValue));
+                }
+            }
+            else
+            {
+                Assert.Equal(short.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<short>(float.MinValue));
+                Assert.Equal(int.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<int>(float.MinValue));
+                Assert.Equal(long.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MinValue));
+                Assert.Equal(nint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<nint>(float.MinValue));
+                Assert.Equal(sbyte.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MinValue));
+            }
+            Assert.Equal(Int128.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<Int128>(float.MinValue));
+
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToIntegerNative<short>(2.6f));
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToIntegerNative<int>(2.6f));
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToIntegerNative<long>(2.6f));
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToIntegerNative<Int128>(2.6f));
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToIntegerNative<nint>(2.6f));
+            Assert.Equal(2, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(2.6f));
+
+            if (Sse2.IsSupported)
+            {
+                // On Xarch:
+                // * Conversion to int is natively supported and returns 0x8000_0000
+                // * Conversion to long is natively supported on 64-bit and returns 0x8000_0000_0000_0000
+
+                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<short>(float.MaxValue));
+                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MaxValue));
+
+                Assert.Equal(int.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<int>(float.MaxValue));
+                Assert.Equal(long.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MaxValue));
+                Assert.Equal(nint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<nint>(float.MaxValue));
+            }
+            else
+            {
+                Assert.Equal(short.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<short>(float.MaxValue));
+                Assert.Equal(int.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<int>(float.MaxValue));
+                Assert.Equal(long.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MaxValue));
+                Assert.Equal(nint.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<nint>(float.MaxValue));
+                Assert.Equal(sbyte.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MaxValue));
+            }
+            Assert.Equal(Int128.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<Int128>(float.MaxValue));
+
+            // Unsigned Values
+
+            if (Sse2.IsSupported)
+            {
+                // On Xarch:
+                // * Conversion to uint is natively supported w/ Avx512 and returns 0xFFFF_FFFF
+                // * Conversion to ulong is natively supported on 64-bit w/ Avx512 and returns 0xFFFF_FFFF_FFFF_FFFF
+
+                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<byte>(float.MinValue));
+                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<ushort>(float.MinValue));
+
+                if (Avx512F.IsSupported)
+                {
+                    Assert.Equal(uint.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<uint>(float.MinValue));
+                    Assert.Equal(nuint.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<nuint>(float.MinValue));
+                }
+                else
+                {
+                    Assert.Equal(uint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<uint>(float.MinValue));
+                    Assert.Equal(nuint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<nuint>(float.MinValue));
+                }
+
+                if (Environment.Is64BitProcess && Avx512F.IsSupported)
+                {
+                    Assert.Equal(ulong.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<ulong>(float.MinValue));
+                }
+                else
+                {
+                    Assert.Equal(ulong.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<ulong>(float.MinValue));
+                }
+            }
+            else
+            {
+                Assert.Equal(byte.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<byte>(float.MinValue));
+                Assert.Equal(ushort.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<ushort>(float.MinValue));
+                Assert.Equal(uint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<uint>(float.MinValue));
+                Assert.Equal(ulong.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<ulong>(float.MinValue));
+                Assert.Equal(nuint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<nuint>(float.MinValue));
+            }
+            Assert.Equal(UInt128.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<UInt128>(float.MinValue));
+
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToIntegerNative<byte>(2.6f));
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToIntegerNative<ushort>(2.6f));
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToIntegerNative<uint>(2.6f));
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToIntegerNative<ulong>(2.6f));
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToIntegerNative<UInt128>(2.6f));
+            Assert.Equal(2u, FloatingPointHelper<float>.ConvertToIntegerNative<nuint>(2.6f));
+
+            if (Sse2.IsSupported)
+            {
+                // On Xarch:
+                // * Conversion to uint is natively supported w/ Avx512 and returns 0xFFFF_FFFF
+                // * Conversion to ulong is natively supported on 64-bit w/ Avx512 and returns 0xFFFF_FFFF_FFFF_FFFF
+
+                Assert.Equal(byte.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<byte>(float.MaxValue));
+                Assert.Equal(ushort.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<ushort>(float.MaxValue));
+            }
+            else
+            {
+                Assert.Equal(byte.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<byte>(float.MaxValue));
+                Assert.Equal(ushort.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<ushort>(float.MaxValue));
+            }
+            Assert.Equal(uint.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<uint>(float.MaxValue));
+            Assert.Equal(ulong.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<ulong>(float.MaxValue));
+            Assert.Equal(nuint.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<nuint>(float.MaxValue));
+            Assert.Equal(new UInt128(0xFFFF_FF00_0000_0000, 0x0000_0000_0000_0000), FloatingPointHelper<float>.ConvertToIntegerNative<UInt128>(float.MaxValue));
+        }
+
         [Fact]
         public static void GetExponentByteCountTest()
         {

From bf890e4baa040c4495164e5c23241f64c4005cdf Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 12 Apr 2024 14:48:46 -0700
Subject: [PATCH 3/4] Applying formatting patch

---
 src/coreclr/jit/gentree.cpp       | 7 ++++---
 src/coreclr/jit/importercalls.cpp | 6 +++---
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
index 08ea188f49f8e..b3f25794c4923 100644
--- a/src/coreclr/jit/gentree.cpp
+++ b/src/coreclr/jit/gentree.cpp
@@ -21442,7 +21442,8 @@ GenTree* Compiler::gtNewSimdCvtNode(var_types   type,
         fixupVal = gtNewSimdCmpOpNode(GT_GE, type, fixupVal, maxVal, simdSourceBaseJitType, simdSize);
 
         // cast it
-        GenTree* castNode = gtNewSimdCvtNativeNode(type, fixupValDup, simdTargetBaseJitType, simdSourceBaseJitType, simdSize);
+        GenTree* castNode =
+            gtNewSimdCvtNativeNode(type, fixupValDup, simdTargetBaseJitType, simdSourceBaseJitType, simdSize);
 
         // use the fixupVal mask with input value and max value to blend
         return gtNewSimdCndSelNode(type, fixupVal, maxValDup, castNode, simdTargetBaseJitType, simdSize);
@@ -21481,8 +21482,8 @@ GenTree* Compiler::gtNewSimdCvtNativeNode(var_types   type,
 
 #if defined(TARGET_XARCH)
     assert(IsBaselineVector512IsaSupportedDebugOnly() ||
-           ((simdTargetBaseType == TYP_INT) && ((simdSize == 16) ||
-                                                (simdSize == 32 && compIsaSupportedDebugOnly(InstructionSet_AVX)))));
+           ((simdTargetBaseType == TYP_INT) &&
+            ((simdSize == 16) || (simdSize == 32 && compIsaSupportedDebugOnly(InstructionSet_AVX)))));
 
     switch (simdSourceBaseJitType)
     {
diff --git a/src/coreclr/jit/importercalls.cpp b/src/coreclr/jit/importercalls.cpp
index e953ea4f2d045..cafee776191da 100644
--- a/src/coreclr/jit/importercalls.cpp
+++ b/src/coreclr/jit/importercalls.cpp
@@ -5173,10 +5173,10 @@ GenTree* Compiler::impPrimitiveNamedIntrinsic(NamedIntrinsic        intrinsic,
 
             var_types tgtType = JitType2PreciseVarType(sig->retType);
             retType           = genActualType(retType);
-            bool      uns     = varTypeIsUnsigned(tgtType) && !varTypeIsSmall(tgtType);
+            bool uns          = varTypeIsUnsigned(tgtType) && !varTypeIsSmall(tgtType);
 
-            GenTree* res      = nullptr;
-            GenTree*  op1     = nullptr;
+            GenTree* res = nullptr;
+            GenTree* op1 = nullptr;
 
 #if defined(TARGET_XARCH) && defined(FEATURE_HW_INTRINSICS)
             if ((intrinsic == NI_PRIMITIVE_ConvertToIntegerNative) && IsBaselineSimdIsaSupported())

From 5e028466e8ef11ba1fdc4ea11d3b03f62877e97c Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 12 Apr 2024 19:34:19 -0700
Subject: [PATCH 4/4] Fixing some tests for x86 and skipping some tests on Mono

---
 .../tests/Vectors/Vector128Tests.cs           |  8 +++
 .../tests/Vectors/Vector256Tests.cs           |  8 +++
 .../tests/Vectors/Vector512Tests.cs           |  8 +++
 .../tests/Vectors/Vector64Tests.cs            |  8 +++
 .../System/DoubleTests.GenericMath.cs         | 58 +++++++-----------
 .../System/SingleTests.GenericMath.cs         | 61 +++++++------------
 6 files changed, 76 insertions(+), 75 deletions(-)

diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
index 345da5e4553b8..95cf6d16b6617 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
@@ -4875,6 +4875,7 @@ public void Log2SingleTest(float value, float expectedResult, float variance)
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt32Test()
         {
             Assert.Equal(Vector128.Create(int.MinValue), Vector128.ConvertToInt32(Vector128.Create(float.MinValue)));
@@ -4883,6 +4884,7 @@ public void ConvertToInt32Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt32NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Sse2.IsSupported)
@@ -4898,6 +4900,7 @@ public void ConvertToInt32NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt64Test()
         {
             Assert.Equal(Vector128.Create(long.MinValue), Vector128.ConvertToInt64(Vector128.Create(double.MinValue)));
@@ -4906,6 +4909,7 @@ public void ConvertToInt64Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt64NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
@@ -4922,6 +4926,7 @@ public void ConvertToInt64NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt32Test()
         {
             Assert.Equal(Vector128.Create(uint.MinValue), Vector128.ConvertToUInt32(Vector128.Create(float.MinValue)));
@@ -4930,6 +4935,7 @@ public void ConvertToUInt32Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt32NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Avx512F.VL.IsSupported)
@@ -4946,6 +4952,7 @@ public void ConvertToUInt32NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt64Test()
         {
             Assert.Equal(Vector128.Create(ulong.MinValue), Vector128.ConvertToUInt64(Vector128.Create(double.MinValue)));
@@ -4954,6 +4961,7 @@ public void ConvertToUInt64Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt64NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
index 7f373a45e790f..a5559d43c8150 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
@@ -5890,6 +5890,7 @@ public void Log2SingleTest(float value, float expectedResult, float variance)
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt32Test()
         {
             Assert.Equal(Vector256.Create(int.MinValue), Vector256.ConvertToInt32(Vector256.Create(float.MinValue)));
@@ -5898,6 +5899,7 @@ public void ConvertToInt32Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt32NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Sse2.IsSupported)
@@ -5913,6 +5915,7 @@ public void ConvertToInt32NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt64Test()
         {
             Assert.Equal(Vector256.Create(long.MinValue), Vector256.ConvertToInt64(Vector256.Create(double.MinValue)));
@@ -5921,6 +5924,7 @@ public void ConvertToInt64Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt64NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
@@ -5937,6 +5941,7 @@ public void ConvertToInt64NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt32Test()
         {
             Assert.Equal(Vector256.Create(uint.MinValue), Vector256.ConvertToUInt32(Vector256.Create(float.MinValue)));
@@ -5945,6 +5950,7 @@ public void ConvertToUInt32Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt32NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Avx512F.VL.IsSupported)
@@ -5961,6 +5967,7 @@ public void ConvertToUInt32NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt64Test()
         {
             Assert.Equal(Vector256.Create(ulong.MinValue), Vector256.ConvertToUInt64(Vector256.Create(double.MinValue)));
@@ -5969,6 +5976,7 @@ public void ConvertToUInt64Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt64NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
index b7d0427a78df5..c01f88facbf57 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
@@ -5323,6 +5323,7 @@ public void Log2SingleTest(float value, float expectedResult, float variance)
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt32Test()
         {
             Assert.Equal(Vector512.Create(int.MinValue), Vector512.ConvertToInt32(Vector512.Create(float.MinValue)));
@@ -5331,6 +5332,7 @@ public void ConvertToInt32Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt32NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Sse2.IsSupported)
@@ -5346,6 +5348,7 @@ public void ConvertToInt32NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt64Test()
         {
             Assert.Equal(Vector512.Create(long.MinValue), Vector512.ConvertToInt64(Vector512.Create(double.MinValue)));
@@ -5354,6 +5357,7 @@ public void ConvertToInt64Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt64NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
@@ -5370,6 +5374,7 @@ public void ConvertToInt64NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt32Test()
         {
             Assert.Equal(Vector512.Create(uint.MinValue), Vector512.ConvertToUInt32(Vector512.Create(float.MinValue)));
@@ -5378,6 +5383,7 @@ public void ConvertToUInt32Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt32NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Avx512F.VL.IsSupported)
@@ -5394,6 +5400,7 @@ public void ConvertToUInt32NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt64Test()
         {
             Assert.Equal(Vector512.Create(ulong.MinValue), Vector512.ConvertToUInt64(Vector512.Create(double.MinValue)));
@@ -5402,6 +5409,7 @@ public void ConvertToUInt64Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt64NativeTest()
         {
             if (Vector128.IsHardwareAccelerated && Avx512DQ.VL.IsSupported)
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
index d974c334946b5..3c2d8064681fe 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
@@ -4290,6 +4290,7 @@ public void Log2SingleTest(float value, float expectedResult, float variance)
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt32Test()
         {
             Assert.Equal(Vector64.Create(int.MinValue), Vector64.ConvertToInt32(Vector64.Create(float.MinValue)));
@@ -4298,6 +4299,7 @@ public void ConvertToInt32Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt32NativeTest()
         {
             Assert.Equal(Vector64.Create(int.MinValue), Vector64.ConvertToInt32Native(Vector64.Create(float.MinValue)));
@@ -4306,6 +4308,7 @@ public void ConvertToInt32NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt64Test()
         {
             Assert.Equal(Vector64.Create(long.MinValue), Vector64.ConvertToInt64(Vector64.Create(double.MinValue)));
@@ -4314,6 +4317,7 @@ public void ConvertToInt64Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToInt64NativeTest()
         {
             Assert.Equal(Vector64.Create(long.MinValue), Vector64.ConvertToInt64Native(Vector64.Create(double.MinValue)));
@@ -4322,6 +4326,7 @@ public void ConvertToInt64NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt32Test()
         {
             Assert.Equal(Vector64.Create(uint.MinValue), Vector64.ConvertToUInt32(Vector64.Create(float.MinValue)));
@@ -4330,6 +4335,7 @@ public void ConvertToUInt32Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt32NativeTest()
         {
             Assert.Equal(Vector64.Create(uint.MinValue), Vector64.ConvertToUInt32Native(Vector64.Create(float.MinValue)));
@@ -4338,6 +4344,7 @@ public void ConvertToUInt32NativeTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt64Test()
         {
             Assert.Equal(Vector64.Create(ulong.MinValue), Vector64.ConvertToUInt64(Vector64.Create(double.MinValue)));
@@ -4346,6 +4353,7 @@ public void ConvertToUInt64Test()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public void ConvertToUInt64NativeTest()
         {
             Assert.Equal(Vector64.Create(ulong.MinValue), Vector64.ConvertToUInt64Native(Vector64.Create(double.MinValue)));
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/DoubleTests.GenericMath.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/DoubleTests.GenericMath.cs
index 5666891611766..d829eb1199d4d 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/DoubleTests.GenericMath.cs
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/DoubleTests.GenericMath.cs
@@ -358,6 +358,7 @@ public static void op_InequalityTest()
         //
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public static void ConvertToIntegerTest()
         {
             // Signed Values
@@ -408,39 +409,17 @@ public static void ConvertToIntegerTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public static void ConvertToIntegerNativeTest()
         {
             // Signed Values
 
-            if (Sse2.IsSupported)
-            {
-                // On Xarch:
-                // * Conversion to int is natively supported and returns 0x8000_0000
-                // * Conversion to long is natively supported on 64-bit and returns 0x8000_0000_0000_0000
-
-                Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<short>(double.MinValue));
-                Assert.Equal(int.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<int>(double.MinValue));
-                Assert.Equal(nint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<nint>(double.MinValue));
-                Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MinValue));
-
-                if (Environment.Is64BitProcess)
-                {
-                    Assert.Equal(long.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MinValue));
-                }
-                else
-                {
-                    Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MinValue));
-                }
-            }
-            else
-            {
-                Assert.Equal(short.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<short>(double.MinValue));
-                Assert.Equal(int.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<int>(double.MinValue));
-                Assert.Equal(long.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MinValue));
-                Assert.Equal(nint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<nint>(double.MinValue));
-                Assert.Equal(sbyte.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MinValue));
-            }
+            Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<short>(double.MinValue));
+            Assert.Equal(int.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<int>(double.MinValue));
+            Assert.Equal(long.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MinValue));
             Assert.Equal(Int128.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<Int128>(double.MinValue));
+            Assert.Equal(nint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<nint>(double.MinValue));
+            Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MinValue));
 
             Assert.Equal(2, FloatingPointHelper<double>.ConvertToIntegerNative<short>(2.6));
             Assert.Equal(2, FloatingPointHelper<double>.ConvertToIntegerNative<int>(2.6));
@@ -456,19 +435,26 @@ public static void ConvertToIntegerNativeTest()
                 // * Conversion to long is natively supported on 64-bit and returns 0x8000_0000_0000_0000
 
                 Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<short>(double.MaxValue));
-                Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MaxValue));
-
                 Assert.Equal(int.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<int>(double.MaxValue));
-                Assert.Equal(long.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MaxValue));
                 Assert.Equal(nint.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<nint>(double.MaxValue));
+                Assert.Equal(0, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MaxValue));
+
+                if (Environment.Is64BitProcess)
+                {
+                    Assert.Equal(long.MinValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MaxValue));
+                }
+                else
+                {
+                    Assert.Equal(long.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MaxValue));
+                }
             }
             else
             {
-                Assert.Equal(short.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<short>(double.MaxValue));
+                Assert.Equal(-1, FloatingPointHelper<double>.ConvertToIntegerNative<short>(double.MaxValue));
                 Assert.Equal(int.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<int>(double.MaxValue));
                 Assert.Equal(long.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<long>(double.MaxValue));
                 Assert.Equal(nint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<nint>(double.MaxValue));
-                Assert.Equal(sbyte.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MaxValue));
+                Assert.Equal(-1, FloatingPointHelper<double>.ConvertToIntegerNative<sbyte>(double.MaxValue));
             }
             Assert.Equal(Int128.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<Int128>(double.MaxValue));
 
@@ -529,12 +515,12 @@ public static void ConvertToIntegerNativeTest()
             else
             {
                 Assert.Equal(byte.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<byte>(double.MaxValue));
-                Assert.Equal(nuint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<nuint>(double.MaxValue));
+                Assert.Equal(ushort.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<ushort>(double.MaxValue));
             }
             Assert.Equal(uint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<uint>(double.MaxValue));
             Assert.Equal(ulong.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<ulong>(double.MaxValue));
             Assert.Equal(UInt128.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<UInt128>(double.MaxValue));
-            Assert.Equal(nuint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<ulong>(double.MaxValue));
+            Assert.Equal(nuint.MaxValue, FloatingPointHelper<double>.ConvertToIntegerNative<nuint>(double.MaxValue));
         }
 
         [Fact]
@@ -1236,7 +1222,7 @@ public static void CreateCheckedFromDecimalTest()
             AssertBitwiseEqual(-0.0, NumberBaseHelper<double>.CreateChecked<decimal>(-0.0m));
             AssertBitwiseEqual(+0.0, NumberBaseHelper<double>.CreateChecked<decimal>(+0.0m));
             AssertBitwiseEqual(+1.0, NumberBaseHelper<double>.CreateChecked<decimal>(+1.0m));
-            AssertBitwiseEqual(+79228162514264337593543950335.0, NumberBaseHelper<double>.CreateChecked<decimal>(decimal.MaxValue));   
+            AssertBitwiseEqual(+79228162514264337593543950335.0, NumberBaseHelper<double>.CreateChecked<decimal>(decimal.MaxValue));
         }
 
         [Fact]
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/SingleTests.GenericMath.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/SingleTests.GenericMath.cs
index 48dd4b5240058..21a4ba2cd77a1 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/SingleTests.GenericMath.cs
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/SingleTests.GenericMath.cs
@@ -358,6 +358,7 @@ public static void op_InequalityTest()
         //
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public static void ConvertToIntegerTest()
         {
             // Signed Values
@@ -408,39 +409,17 @@ public static void ConvertToIntegerTest()
         }
 
         [Fact]
+        [SkipOnMono("https://github.com/dotnet/runtime/issues/100368")]
         public static void ConvertToIntegerNativeTest()
         {
             // Signed Values
 
-            if (Sse2.IsSupported)
-            {
-                // On Xarch:
-                // * Conversion to int is natively supported and returns 0x8000_0000
-                // * Conversion to long is natively supported on 64-bit and returns 0x8000_0000_0000_0000
-
-                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<short>(float.MinValue));
-                Assert.Equal(int.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<int>(float.MinValue));
-                Assert.Equal(nint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<nint>(float.MinValue));
-                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MinValue));
-
-                if (Environment.Is64BitProcess)
-                {
-                    Assert.Equal(long.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MinValue));
-                }
-                else
-                {
-                    Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MinValue));
-                }
-            }
-            else
-            {
-                Assert.Equal(short.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<short>(float.MinValue));
-                Assert.Equal(int.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<int>(float.MinValue));
-                Assert.Equal(long.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MinValue));
-                Assert.Equal(nint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<nint>(float.MinValue));
-                Assert.Equal(sbyte.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MinValue));
-            }
+            Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<short>(float.MinValue));
+            Assert.Equal(int.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<int>(float.MinValue));
+            Assert.Equal(long.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MinValue));
             Assert.Equal(Int128.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<Int128>(float.MinValue));
+            Assert.Equal(nint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<nint>(float.MinValue));
+            Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MinValue));
 
             Assert.Equal(2, FloatingPointHelper<float>.ConvertToIntegerNative<short>(2.6f));
             Assert.Equal(2, FloatingPointHelper<float>.ConvertToIntegerNative<int>(2.6f));
@@ -456,19 +435,26 @@ public static void ConvertToIntegerNativeTest()
                 // * Conversion to long is natively supported on 64-bit and returns 0x8000_0000_0000_0000
 
                 Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<short>(float.MaxValue));
-                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MaxValue));
-
                 Assert.Equal(int.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<int>(float.MaxValue));
-                Assert.Equal(long.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MaxValue));
                 Assert.Equal(nint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<nint>(float.MaxValue));
+                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MaxValue));
+
+                if (Environment.Is64BitProcess)
+                {
+                    Assert.Equal(long.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MaxValue));
+                }
+                else
+                {
+                    Assert.Equal(long.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MaxValue));
+                }
             }
             else
             {
-                Assert.Equal(short.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<short>(float.MaxValue));
+                Assert.Equal(-1, FloatingPointHelper<float>.ConvertToIntegerNative<short>(float.MaxValue));
                 Assert.Equal(int.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<int>(float.MaxValue));
                 Assert.Equal(long.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<long>(float.MaxValue));
                 Assert.Equal(nint.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<nint>(float.MaxValue));
-                Assert.Equal(sbyte.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MaxValue));
+                Assert.Equal(-1, FloatingPointHelper<float>.ConvertToIntegerNative<sbyte>(float.MaxValue));
             }
             Assert.Equal(Int128.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<Int128>(float.MaxValue));
 
@@ -480,9 +466,6 @@ public static void ConvertToIntegerNativeTest()
                 // * Conversion to uint is natively supported w/ Avx512 and returns 0xFFFF_FFFF
                 // * Conversion to ulong is natively supported on 64-bit w/ Avx512 and returns 0xFFFF_FFFF_FFFF_FFFF
 
-                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<byte>(float.MinValue));
-                Assert.Equal(0, FloatingPointHelper<float>.ConvertToIntegerNative<ushort>(float.MinValue));
-
                 if (Avx512F.IsSupported)
                 {
                     Assert.Equal(uint.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<uint>(float.MinValue));
@@ -505,12 +488,12 @@ public static void ConvertToIntegerNativeTest()
             }
             else
             {
-                Assert.Equal(byte.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<byte>(float.MinValue));
-                Assert.Equal(ushort.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<ushort>(float.MinValue));
                 Assert.Equal(uint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<uint>(float.MinValue));
                 Assert.Equal(ulong.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<ulong>(float.MinValue));
                 Assert.Equal(nuint.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<nuint>(float.MinValue));
             }
+            Assert.Equal(byte.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<byte>(float.MinValue));
+            Assert.Equal(ushort.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<ushort>(float.MinValue));
             Assert.Equal(UInt128.MinValue, FloatingPointHelper<float>.ConvertToIntegerNative<UInt128>(float.MinValue));
 
             Assert.Equal(2u, FloatingPointHelper<float>.ConvertToIntegerNative<byte>(2.6f));
@@ -536,8 +519,8 @@ public static void ConvertToIntegerNativeTest()
             }
             Assert.Equal(uint.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<uint>(float.MaxValue));
             Assert.Equal(ulong.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<ulong>(float.MaxValue));
-            Assert.Equal(nuint.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<nuint>(float.MaxValue));
             Assert.Equal(new UInt128(0xFFFF_FF00_0000_0000, 0x0000_0000_0000_0000), FloatingPointHelper<float>.ConvertToIntegerNative<UInt128>(float.MaxValue));
+            Assert.Equal(nuint.MaxValue, FloatingPointHelper<float>.ConvertToIntegerNative<nuint>(float.MaxValue));
         }
 
         [Fact]