Some cleanup of the Math functions from #20788

cross/android/arm/tryrun.cmake

@@ -6,6 +6,14 @@ SET( HAVE_COMPATIBLE_EXP_EXITCODE
      1
      CACHE STRING "Result from TRY_RUN" FORCE)
 
+SET( HAVE_COMPATIBLE_ILOGB0_EXITCODE 
+     0
+     CACHE STRING "Result from TRY_RUN" FORCE)
+
+SET( HAVE_COMPATIBLE_ILOGBNAN_EXITCODE 
+     0
+     CACHE STRING "Result from TRY_RUN" FORCE)
+
 SET( REALPATH_SUPPORTS_NONEXISTENT_FILES_EXITCODE 
      1
      CACHE STRING "Result from TRY_RUN" FORCE)

cross/android/arm64/tryrun.cmake

@@ -2,6 +2,14 @@ SET( HAVE_COMPATIBLE_EXP_EXITCODE
      1
      CACHE STRING "Result from TRY_RUN" FORCE)
 
+SET( HAVE_COMPATIBLE_ILOGB0_EXITCODE 
+     0
+     CACHE STRING "Result from TRY_RUN" FORCE)
+
+SET( HAVE_COMPATIBLE_ILOGBNAN_EXITCODE 
+     0
+     CACHE STRING "Result from TRY_RUN" FORCE)
+
 SET( REALPATH_SUPPORTS_NONEXISTENT_FILES_EXITCODE 
      1
      CACHE STRING "Result from TRY_RUN" FORCE)

cross/tryrun.cmake

@@ -23,6 +23,8 @@ if(TARGET_ARCH_NAME MATCHES "^(armel|arm|arm64|x86)$")
   set_cache_value(HAVE_COMPATIBLE_ACOS_EXITCODE 0)
   set_cache_value(HAVE_COMPATIBLE_ASIN_EXITCODE 0)
   set_cache_value(HAVE_COMPATIBLE_ATAN2_EXITCODE 0)
+  set_cache_value(HAVE_COMPATIBLE_ILOGB0_EXITCODE 0)
+  set_cache_value(HAVE_COMPATIBLE_ILOGBNAN_EXITCODE 0)
   set_cache_value(HAVE_COMPATIBLE_LOG10_EXITCODE 0)
   set_cache_value(HAVE_COMPATIBLE_LOG_EXITCODE 0)
   set_cache_value(HAVE_COMPATIBLE_POW_EXITCODE 0)

src/System.Private.CoreLib/shared/System/Math.cs

@@ -538,17 +538,31 @@ public static decimal Max(decimal val1, decimal val2)
 
         public static double Max(double val1, double val2)
         {
-            if (val1 > val2)
+            // When val1 and val2 are both finite or infinite, return the larger
+            //  * We count +0.0 as larger than -0.0 to match MSVC
+            // When val1 or val2, but not both, are NaN return the opposite
+            //  * We return the opposite if either is NaN to match MSVC
+
+            if (double.IsNaN(val1))
             {
-                return val1;
+                return val2;
             }
 
-            if (double.IsNaN(val1))
+            if (double.IsNaN(val2))
             {
                 return val1;
             }
 
-            return val2;
+            // We do this comparison first and separately to handle the -0.0 to +0.0 comparision
+            // * Doing (val1 < val2) first could get transformed into (val2 >= val1) by the JIT
+            //   which would then return an incorrect value
+
+            if (val1 == val2)
+            {
+                return double.IsNegative(val1) ? val2 : val1;
+            }
+
+            return (val1 < val2) ? val2 : val1;
         }
 
         [NonVersionable]
@@ -578,17 +592,31 @@ public static sbyte Max(sbyte val1, sbyte val2)
 
         public static float Max(float val1, float val2)
         {
-            if (val1 > val2)
+            // When val1 and val2 are both finite or infinite, return the larger
+            //  * We count +0.0 as larger than -0.0 to match MSVC
+            // When val1 or val2, but not both, are NaN return the opposite
+            //  * We return the opposite if either is NaN to match MSVC
+
+            if (float.IsNaN(val1))
             {
-                return val1;
+                return val2;
             }
 
-            if (float.IsNaN(val1))
+            if (float.IsNaN(val2))
             {
                 return val1;
             }
 
-            return val2;
+            // We do this comparison first and separately to handle the -0.0 to +0.0 comparision
+            // * Doing (val1 < val2) first could get transformed into (val2 >= val1) by the JIT
+            //   which would then return an incorrect value
+
+            if (val1 == val2)
+            {
+                return float.IsNegative(val1) ? val2 : val1;
+            }
+
+            return (val1 < val2) ? val2 : val1;
         }
 
         [CLSCompliant(false)]
@@ -614,7 +642,31 @@ public static ulong Max(ulong val1, ulong val2)
 
         public static double MaxMagnitude(double x, double y)
         {
-            return Max(Abs(x), Abs(y));
+            // When x and y are both finite or infinite, return the larger magnitude
+            //  * We count +0.0 as larger than -0.0 to match MSVC
+            // When x or y, but not both, are NaN return the opposite
+            //  * We return the opposite if either is NaN to match MSVC
+
+            if (double.IsNaN(x))
+            {
+                return y;
+            }
+
+            if (double.IsNaN(y))
+            {
+                return x;
+            }
+
+            // We do this comparison first and separately to handle the -0.0 to +0.0 comparision
+            // * Doing (x < y) first could get transformed into (y >= x) by the JIT which would
+            //   then return an incorrect value
+
+            if (x == y)
+            {
+                return double.IsNegative(x) ? y : x;
+            }
+
+            return (Abs(x) < Abs(y)) ? y : x;
         }
 
         [NonVersionable]
@@ -631,17 +683,31 @@ public static decimal Min(decimal val1, decimal val2)
 
         public static double Min(double val1, double val2)
         {
-            if (val1 < val2)
+            // When val1 and val2 are both finite or infinite, return the smaller
+            //  * We count -0.0 as smaller than -0.0 to match MSVC
+            // When val1 or val2, but not both, are NaN return the opposite
+            //  * We return the opposite if either is NaN to match MSVC
+
+            if (double.IsNaN(val1))
             {
-                return val1;
+                return val2;
             }
 
-            if (double.IsNaN(val1))
+            if (double.IsNaN(val2))
             {
                 return val1;
             }
 
-            return val2;
+            // We do this comparison first and separately to handle the -0.0 to +0.0 comparision
+            // * Doing (val1 < val2) first could get transformed into (val2 >= val1) by the JIT
+            //   which would then return an incorrect value
+
+            if (val1 == val2)
+            {
+                return double.IsNegative(val1) ? val1 : val2;
+            }
+
+            return (val1 < val2) ? val1 : val2;
         }
 
         [NonVersionable]
@@ -671,17 +737,31 @@ public static sbyte Min(sbyte val1, sbyte val2)
 
         public static float Min(float val1, float val2)
         {
-            if (val1 < val2)
+            // When val1 and val2 are both finite or infinite, return the smaller
+            //  * We count -0.0 as smaller than -0.0 to match MSVC
+            // When val1 or val2, but not both, are NaN return the opposite
+            //  * We return the opposite if either is NaN to match MSVC
+
+            if (float.IsNaN(val1))
             {
-                return val1;
+                return val2;
             }
 
-            if (float.IsNaN(val1))
+            if (float.IsNaN(val2))
             {
                 return val1;
             }
 
-            return val2;
+            // We do this comparison first and separately to handle the -0.0 to +0.0 comparision
+            // * Doing (val1 < val2) first could get transformed into (val2 >= val1) by the JIT
+            //   which would then return an incorrect value
+
+            if (val1 == val2)
+            {
+                return float.IsNegative(val1) ? val1 : val2;
+            }
+
+            return (val1 < val2) ? val1 : val2;
         }
 
         [CLSCompliant(false)]
@@ -707,7 +787,31 @@ public static ulong Min(ulong val1, ulong val2)
 
         public static double MinMagnitude(double x, double y)
         {
-            return Min(Abs(x), Abs(y));
+            // When x and y are both finite or infinite, return the smaller magnitude
+            //  * We count -0.0 as smaller than -0.0 to match MSVC
+            // When x or y, but not both, are NaN return the opposite
+            //  * We return the opposite if either is NaN to match MSVC
+
+            if (double.IsNaN(x))
+            {
+                return y;
+            }
+
+            if (double.IsNaN(y))
+            {
+                return x;
+            }
+
+            // We do this comparison first and separately to handle the -0.0 to +0.0 comparision
+            // * Doing (x < y) first could get transformed into (y >= x) by the JIT which would
+            //   then return an incorrect value
+
+            if (x == y)
+            {
+                return double.IsNegative(x) ? x : y;
+            }
+
+            return (Abs(x) < Abs(y)) ? x : y;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/System.Private.CoreLib/shared/System/MathF.cs

@@ -190,7 +190,31 @@ public static float Max(float x, float y)
 
         public static float MaxMagnitude(float x, float y)
         {
-            return Max(Abs(x), Abs(y));
+            // When x and y are both finite or infinite, return the larger magnitude
+            //  * We count +0.0 as larger than -0.0 to match MSVC
+            // When x or y, but not both, are NaN return the opposite
+            //  * We return the opposite if either is NaN to match MSVC
+
+            if (float.IsNaN(x))
+            {
+                return y;
+            }
+
+            if (float.IsNaN(y))
+            {
+                return x;
+            }
+
+            // We do this comparison first and separately to handle the -0.0 to +0.0 comparision
+            // * Doing (x < y) first could get transformed into (y >= x) by the JIT which would
+            //   then return an incorrect value
+
+            if (x == y)
+            {
+                return float.IsNegative(x) ? y : x;
+            }
+
+            return (Abs(x) < Abs(y)) ? y : x;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -201,7 +225,31 @@ public static float Min(float x, float y)
 
         public static float MinMagnitude(float x, float y)
         {
-            return Min(Abs(x), Abs(y));
+            // When x and y are both finite or infinite, return the smaller magnitude
+            //  * We count -0.0 as smaller than -0.0 to match MSVC
+            // When x or y, but not both, are NaN return the opposite
+            //  * We return the opposite if either is NaN to match MSVC
+
+            if (float.IsNaN(x))
+            {
+                return y;
+            }
+
+            if (float.IsNaN(y))
+            {
+                return x;
+            }
+
+            // We do this comparison first and separately to handle the -0.0 to +0.0 comparision
+            // * Doing (x < y) first could get transformed into (y >= x) by the JIT which would
+            //   then return an incorrect value
+
+            if (x == y)
+            {
+                return float.IsNegative(x) ? x : y;
+            }
+
+            return (Abs(x) < Abs(y)) ? x : y;
         }
 
         [Intrinsic]

src/System.Private.CoreLib/src/System/Math.CoreCLR.cs

@@ -68,7 +68,7 @@ public static partial class Math
         public static extern double FusedMultiplyAdd(double x, double y, double z);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        public static extern int IlogB(double x);
+        public static extern int ILogB(double x);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         public static extern double Log(double d);

src/System.Private.CoreLib/src/System/MathF.CoreCLR.cs

@@ -59,7 +59,7 @@ public static partial class MathF
         public static extern float FusedMultiplyAdd(float x, float y, float z);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        public static extern int IlogB(float x);
+        public static extern int ILogB(float x);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         public static extern float Log(float x);

src/classlibnative/float/floatdouble.cpp

@@ -212,7 +212,7 @@ FCIMPLEND
 /*=====================================Ilog2====================================
 **
 ==============================================================================*/
-FCIMPL1_V(int, COMDouble::IlogB, double x)
+FCIMPL1_V(int, COMDouble::ILogB, double x)
     FCALL_CONTRACT;
 
     return (int)ilogb(x);

src/classlibnative/float/floatsingle.cpp

@@ -199,7 +199,7 @@ FCIMPLEND
 /*=====================================Ilog2====================================
 **
 ==============================================================================*/
-FCIMPL1_V(int, COMSingle::IlogB, float x)
+FCIMPL1_V(int, COMSingle::ILogB, float x)
     FCALL_CONTRACT;
 
     return (int)ilogbf(x);

src/classlibnative/inc/floatdouble.h

@@ -26,7 +26,7 @@ class COMDouble {
     FCDECL1_V(static double, Floor, double x);
     FCDECL2_VV(static double, FMod, double x, double y);
     FCDECL3_VVV(static double, FusedMultiplyAdd, double x, double y, double z);
-    FCDECL1_V(static int, IlogB, double x);
+    FCDECL1_V(static int, ILogB, double x);
     FCDECL1_V(static double, Log, double x);
     FCDECL1_V(static double, Log2, double x);
     FCDECL1_V(static double, Log10, double x);

src/classlibnative/inc/floatsingle.h

@@ -26,7 +26,7 @@ class COMSingle {
     FCDECL1_V(static float, Floor, float x);
     FCDECL2_VV(static float, FMod, float x, float y);
     FCDECL3_VVV(static float, FusedMultiplyAdd, float x, float y, float z);
-    FCDECL1_V(static int, IlogB, float x);
+    FCDECL1_V(static int, ILogB, float x);
     FCDECL1_V(static float, Log, float x);
     FCDECL1_V(static float, Log2, float x);
     FCDECL1_V(static float, Log10, float x);

src/pal/src/config.h.in

@@ -125,6 +125,8 @@
 #cmakedefine01 HAVE_VALID_POSITIVE_INF_POW
 #cmakedefine01 HAVE_COMPATIBLE_ATAN2
 #cmakedefine01 HAVE_COMPATIBLE_EXP
+#cmakedefine01 HAVE_COMPATIBLE_ILOGB0
+#cmakedefine01 HAVE_COMPATIBLE_ILOGBNAN
 #cmakedefine01 HAVE_COMPATIBLE_LOG
 #cmakedefine01 HAVE_COMPATIBLE_LOG10
 #cmakedefine01 UNGETC_NOT_RETURN_EOF