Fix Scalar.Abs for TInteger.MinValue (#95597)

* Fix Scalar.Abs for TInteger.MinValue

Fixes #95592.

* Fix build, add tests

Author: MichalPetryka

src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Scalar.cs

@@ -139,30 +139,55 @@ public static T One
         public static T Abs(T value)
         {
             // byte, ushort, uint, and ulong should have already been handled
-
+            // avoid Math.Abs for integers since it throws for MinValue
             if (typeof(T) == typeof(double))
             {
                 return (T)(object)Math.Abs((double)(object)value);
             }
             else if (typeof(T) == typeof(short))
             {
-                return (T)(object)Math.Abs((short)(object)value);
+                short v = (short)(object)value;
+                if (v < 0)
+                {
+                    v = (short)-v;
+                }
+                return (T)(object)v;
             }
             else if (typeof(T) == typeof(int))
             {
-                return (T)(object)Math.Abs((int)(object)value);
+                int v = (int)(object)value;
+                if (v < 0)
+                {
+                    v = -v;
+                }
+                return (T)(object)v;
             }
             else if (typeof(T) == typeof(long))
             {
-                return (T)(object)Math.Abs((long)(object)value);
+                long v = (long)(object)value;
+                if (v < 0)
+                {
+                    v = -v;
+                }
+                return (T)(object)v;
             }
             else if (typeof(T) == typeof(nint))
             {
-                return (T)(object)Math.Abs((nint)(object)value);
+                nint v = (nint)(object)value;
+                if (v < 0)
+                {
+                    v = -v;
+                }
+                return (T)(object)v;
             }
             else if (typeof(T) == typeof(sbyte))
             {
-                return (T)(object)Math.Abs((sbyte)(object)value);
+                sbyte v = (sbyte)(object)value;
+                if (v < 0)
+                {
+                    v = (sbyte)-v;
+                }
+                return (T)(object)v;
             }
             else if (typeof(T) == typeof(float))
             {

src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs

@@ -4533,6 +4533,17 @@ public void Vector128SingleCopyToOffsetTest()
             Assert.True(array.AsSpan().SequenceEqual([0.0f, 2.0f, 2.0f, 2.0f, 2.0f]));
         }
 
+        [Fact]
+        public void Vector128SByteAbs_MinValue()
+        {
+            Vector128<sbyte> vector = Vector128.Create(sbyte.MinValue);
+            Vector128<sbyte> abs = Vector128.Abs(vector);
+            for (int index = 0; index < Vector128<sbyte>.Count; index++)
+            {
+                Assert.Equal(sbyte.MinValue, vector.GetElement(index));
+            }
+        }
+
         [Fact]
         public void IsSupportedByte() => TestIsSupported<byte>();
 

src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs

@@ -5555,6 +5555,17 @@ public void Vector256SingleCopyToOffsetTest()
             Assert.True(array.AsSpan().SequenceEqual([0.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f]));
         }
 
+        [Fact]
+        public void Vector256SByteAbs_MinValue()
+        {
+            Vector256<sbyte> vector = Vector256.Create(sbyte.MinValue);
+            Vector256<sbyte> abs = Vector256.Abs(vector);
+            for (int index = 0; index < Vector256<sbyte>.Count; index++)
+            {
+                Assert.Equal(sbyte.MinValue, vector.GetElement(index));
+            }
+        }
+
         [Fact]
         public void IsSupportedByte() => TestIsSupported<byte>();
 

src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs

@@ -5032,6 +5032,17 @@ public void Vector512SingleCopyToOffsetTest()
             Assert.True(array.AsSpan().SequenceEqual([0.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f]));
         }
 
+        [Fact]
+        public void Vector512SByteAbs_MinValue()
+        {
+            Vector512<sbyte> vector = Vector512.Create(sbyte.MinValue);
+            Vector512<sbyte> abs = Vector512.Abs(vector);
+            for (int index = 0; index < Vector512<sbyte>.Count; index++)
+            {
+                Assert.Equal(sbyte.MinValue, vector.GetElement(index));
+            }
+        }
+
         [Fact]
         public void IsSupportedByte() => TestIsSupported<byte>();
 

src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs

@@ -3953,6 +3953,17 @@ public void Vector64SingleCopyToOffsetTest()
             Assert.True(array.AsSpan().SequenceEqual([0.0f, 2.0f, 2.0f]));
         }
 
+        [Fact]
+        public void Vector64SByteAbs_MinValue()
+        {
+            Vector64<sbyte> vector = Vector64.Create(sbyte.MinValue);
+            Vector64<sbyte> abs = Vector64.Abs(vector);
+            for (int index = 0; index < Vector64<sbyte>.Count; index++)
+            {
+                Assert.Equal(sbyte.MinValue, vector.GetElement(index));
+            }
+        }
+
         [Fact]
         public void IsSupportedByte() => TestIsSupported<byte>();