Simplify SVE unary test template (#118129)

* Replace DataTable with PinnedVector class
* Add functions for generating random Vectors
* Add functions for converting between Vector and Array types
* Generate an expected Vector for comparison and log to terminal
* Simplify validation functions
* Remove RetVectorType and Op1VectorType template variables

Author: snickolls-arm

src/tests/Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj

@@ -16,6 +16,7 @@
     <Compile Include="CoreClrConfigurationDetection.cs" />
     <Compile Include="OutOfProcessTest.cs" />
     <Compile Include="PlatformDetection.cs" />
+    <Compile Include="Vectors.cs" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\Coreclr.TestWrapper\CoreclrTestWrapperLib.cs" Link="CoreclrTestWrapperLib.cs" />

src/tests/Common/CoreCLRTestLibrary/Vectors.cs

@@ -0,0 +1,115 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace TestLibrary
+{
+    public static class Vectors
+    {
+        public static void VectorToArray<T>(ref T[] dst, Vector<T> src) where T : struct
+        {
+            Span<byte> span = MemoryMarshal.AsBytes(dst.AsSpan());
+            MemoryMarshal.Write(span, src);
+        }
+
+        public static Vector<T> GetRandomVector<T>()
+        {
+            long vsize = Unsafe.SizeOf<Vector<T>>();
+            byte[] data = new byte[vsize];
+            for (int i = 0; i < vsize; i++)
+            {
+                data[i] = TestLibrary.Generator.GetByte();
+            }
+            return new Vector<T>(data.AsSpan());
+        }
+
+        public static Vector<T> GetRandomMask<T>()
+        {
+            long vsize = Unsafe.SizeOf<Vector<T>>();
+            long tsize = Unsafe.SizeOf<T>();
+
+            byte[] data = new byte[vsize];
+
+            long count = vsize / tsize;
+            for (int i = 0; i < count; i++)
+            {
+                data[i * tsize] |= (byte)(TestLibrary.Generator.GetByte() & 1);
+            }
+
+            return new Vector<T>(data.AsSpan());
+        }
+
+        public class PinnedVector<T> where T : struct
+        {
+            private byte[] buf;
+            private GCHandle inHandle;
+            private ulong alignment;
+
+            private void Alloc(T[] data, int alignment)
+            {
+                unsafe
+                {
+                    int sizeOfinArray1 = data.Length * Unsafe.SizeOf<T>();
+                    if ((alignment != 64 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1)
+                    {
+                        throw new ArgumentException($"Invalid value of alignment: {alignment}, sizeOfinArray1: {sizeOfinArray1}");
+                    }
+
+                    buf = new byte[alignment * 2];
+                    inHandle = GCHandle.Alloc(buf, GCHandleType.Pinned);
+                    this.alignment = (ulong)alignment;
+                    Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(Ptr), ref Unsafe.As<T, byte>(ref data[0]), (uint)sizeOfinArray1);
+                }
+            }
+
+            public PinnedVector(T[] data, int alignment)
+            {
+                Alloc(data, alignment);
+            }
+
+            public PinnedVector(Vector<T> inVector, int alignment)
+            {
+                long tsize = Unsafe.SizeOf<T>();
+                long vsize = Unsafe.SizeOf<Vector<T>>();
+                long count = vsize / tsize;
+                T[] data = new T[count];
+                VectorToArray(ref data, inVector);
+                Alloc(data, alignment);
+            }
+
+            public unsafe void* Ptr => Align((byte*)inHandle.AddrOfPinnedObject().ToPointer(), alignment);
+
+            public void Dispose()
+            {
+                inHandle.Free();
+            }
+
+            private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
+            {
+                return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
+            }
+
+            public Vector<T> Value
+            {
+                get
+                {
+                    unsafe
+                    {
+                        return Unsafe.Read<Vector<T>>(Ptr);
+                    }
+                }
+                set
+                {
+                    unsafe
+                    {
+                        Unsafe.Write(Ptr, value);
+                    }
+                }
+            }
+        }
+    }
+}

src/tests/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs

@@ -1227,7 +1227,8 @@ public static T ShiftRight<T>(T op1, ulong op2) where T : INumber<T>
         public static T SignExtend<T>(T n, int numBits, bool zeroExtend) where T : struct, IComparable, IConvertible
         {
             // Get the underlying integer value
-            dynamic value = Convert.ChangeType(n, typeof(long));
+            dynamic value = n;
+            value = (long)value;
 
             // Mask to extract the lowest numBits
             long mask = (1L << numBits) - 1;
@@ -4540,10 +4541,25 @@ private static uint ReciprocalSqrtEstimate(uint a)
 
         public static double ReciprocalExponent(double op1)
         {
+            if (double.IsNaN(op1))
+            {
+                return double.NaN;
+            }
+
             ulong bits = (ulong)BitConverter.DoubleToUInt64Bits(op1);
+            ulong exp = bits & 0x7FF0000000000000;
+
+            if (exp == 0)
+            {
+                // Replace exponent with maximum exponent
+                bits ^= exp ^ 0x7FE0000000000000;
+            }
+            else
+            {
+                // Invert the exponent
+                bits ^= 0x7FF0000000000000;
+            }
 
-            // Invert the exponent
-            bits ^= 0x7FF0000000000000;
             // Zero the fraction
             bits &= 0xFFF0000000000000;
 
@@ -4552,10 +4568,25 @@ public static double ReciprocalExponent(double op1)
 
         public static float ReciprocalExponent(float op1)
         {
+            if (float.IsNaN(op1))
+            {
+                return float.NaN;
+            }
+
             uint bits = BitConverter.SingleToUInt32Bits(op1);
+            uint exp = bits & 0x7F800000;
+
+            if (exp == 0)
+            {
+                // Replace exponent with maximum exponent
+                bits ^= exp ^ 0x7F000000;
+            }
+            else
+            {
+                // Invert the exponent
+                bits ^= 0x7F800000;
+            }
 
-            // Invert the exponent
-            bits ^= 0x7F800000;
             // Zero the fraction
             bits &= 0xFF800000;