Resolves an assert around Sse41.ConvertToVector128Int* and Avx2.ConvertToVector256Int* (#24289)

* Adding tests for the overloads of Sse41.ConvertToVector128Int* and Avx2.ConvertToVector256Int* that take a pointer

* Fixing the handling of Sse41.ConvertToVector128* and Avx2.ConvertToVector256*

24 files changed, 672 insertions, 0 deletions

diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.Byte.cs
index ebaea926c6..2a4800189f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.Byte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int16(
+                (Byte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int16(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(Byte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int16>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(Vector128<Byte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.SByte.cs
index 92b47e7eba..21beb9dd3c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.SByte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int16(
+                (SByte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int16(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(SByte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int16>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(Vector128<SByte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Byte.cs
index 172ce8539d..ac163d11a3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Byte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int32(
+                (Byte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int32(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Byte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<Byte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Int16.cs
index a197da2439..777b6f244c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Int16.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int32(
+                (Int16*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int32(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Int16*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Int16*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<Int16>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.SByte.cs
index 47af229606..d824f5686f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.SByte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int32(
+                (SByte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int32(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(SByte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<SByte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.UInt16.cs
index 8020d84a91..dbdb145706 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.UInt16.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int32(
+                (UInt16*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int32(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(UInt16*) })
+                                     .Invoke(null, new object[] {
+                                         Pointer.Box(_dataTable.inArrayPtr, typeof(UInt16*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<UInt16>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Byte.cs
index 80c10fed28..cc1862d98b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Byte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int64(
+                (Byte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Byte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<Byte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int16.cs
index 092610d61d..aff546dff9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int16.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int64(
+                (Int16*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Int16*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Int16*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<Int16>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int32.cs
index f1c16ee090..c93d69b07f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int32.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int64(
+                (Int32*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Int32*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Int32*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<Int32>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.SByte.cs
index f3848d55e6..1058faaf20 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.SByte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int64(
+                (SByte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(SByte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<SByte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt16.cs
index 63a9e20823..abd6201e1a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt16.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int64(
+                (UInt16*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(UInt16*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(UInt16*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<UInt16>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt32.cs
index 2fd078610b..54ecb60936 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt32.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Avx.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Avx2.ConvertToVector256Int64(
+                (UInt32*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Avx2.ConvertToVector256Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(UInt32*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(UInt32*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<UInt32>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.Byte.cs
index 67ee09b11d..d1353b21ef 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.Byte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int16(
+                (Byte*)_dataTable.inArrayPtr
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int16(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int16), new Type[] { typeof(Byte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int16>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int16), new Type[] { typeof(Vector128<Byte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.SByte.cs
index 8f4ea820dd..ccc1010cd4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.SByte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int16(
+                (SByte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int16(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int16), new Type[] { typeof(SByte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int16>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int16), new Type[] { typeof(Vector128<SByte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Byte.cs
index f48f8d48e9..2877d2e767 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Byte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int32(
+                (Byte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int32(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Byte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Vector128<Byte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Int16.cs
index ed1d1ee976..403e12f4fb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Int16.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int32(
+                (Int16*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int32(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Int16*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Int16*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Vector128<Int16>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.SByte.cs
index 73f87e4e42..a4285ecce5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.SByte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int32(
+                (SByte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int32(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(SByte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Vector128<SByte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.UInt16.cs
index 27976d60b0..c1fcecb708 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.UInt16.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int32(
+                (UInt16*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int32(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(UInt16*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(UInt16*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Vector128<UInt16>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Byte.cs
index 63ea6c7c34..0cdd7768ea 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Byte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int64(
+                (Byte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Byte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<Byte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int16.cs
index fa76d77890..9d1caef482 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int16.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int64(
+                (Int16*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Int16*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Int16*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<Int16>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int32.cs
index 870ad738a3..f19e7838a2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int32.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int64(
+                (Int32*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Int32*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(Int32*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<Int32>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.SByte.cs
index ba2859cc68..d8ef38562d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.SByte.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int64(
+                (SByte*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(SByte*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<SByte>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt16.cs
index 1ea8e06a20..f81b199dce 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt16.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int64(
+                (UInt16*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(UInt16*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(UInt16*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<UInt16>) })
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt32.cs
index 9e58baad22..18e2233ad4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt32.cs
@@ -10,6 +10,7 @@
  ******************************************************************************/
 
 using System;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
+                // Validates basic functionality works, using the pointer overload
+                test.RunBasicScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates basic functionality works, using Load
@@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
+                // Validates calling via reflection works, using the pointer overload
+                test.RunReflectionScenario_Ptr();
+
                 if (Sse2.IsSupported)
                 {
                     // Validates calling via reflection works, using Load
@@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunBasicScenario_Ptr()
+        {
+            var result = Sse41.ConvertToVector128Int64(
+                (UInt32*)(_dataTable.inArrayPtr)
+            );
+
+            Unsafe.Write(_dataTable.outArrayPtr, result);
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunBasicScenario_Load()
         {
             var result = Sse41.ConvertToVector128Int64(
@@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
         }
 
+        public void RunReflectionScenario_Ptr()
+        {
+            var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(UInt32*) })
+                                     .Invoke(null, new object[] {
+                                        Pointer.Box(_dataTable.inArrayPtr, typeof(UInt32*))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result));
+            ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
+        }
+
         public void RunReflectionScenario_Load()
         {
             var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<UInt32>) })