Change the ReciprocalEstimate and ReciprocalSqrtEstimate APIs to be mustExpand on RyuJIT

src/coreclr/jit/importercalls.cpp

@@ -3125,15 +3125,7 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
     // To be fixed in https://github.com/dotnet/runtime/pull/77465
     const bool tier0opts = !opts.compDbgCode && !opts.jitFlags->IsSet(JitFlags::JIT_FLAG_MIN_OPT);
 
-    if (tier0opts)
-    {
-        // The *Estimate APIs are allowed to differ in behavior across hardware
-        // so ensure we treat them as "betterToExpand" to get deterministic behavior
-
-        betterToExpand |= (ni == NI_System_Math_ReciprocalEstimate);
-        betterToExpand |= (ni == NI_System_Math_ReciprocalSqrtEstimate);
-    }
-    else if (!mustExpand)
+    if (!mustExpand)
     {
         switch (ni)
         {
@@ -7471,6 +7463,8 @@ bool Compiler::IsTargetIntrinsic(NamedIntrinsic intrinsicName)
     {
         case NI_System_Math_Abs:
         case NI_System_Math_Sqrt:
+        case NI_System_Math_ReciprocalEstimate:
+        case NI_System_Math_ReciprocalSqrtEstimate:
             return true;
 
         default:
@@ -8847,7 +8841,7 @@ GenTree* Compiler::impEstimateIntrinsic(CORINFO_METHOD_HANDLE method,
             simdSize = 16;
         }
 
-        GenTree* op1 = impPopStack().val;
+        GenTree* op1 = impImplicitR4orR8Cast(impPopStack().val, callType);
 
         op1 = gtNewSimdCreateScalarUnsafeNode(simdType, op1, callJitType, simdSize);
         op1 = gtNewSimdHWIntrinsicNode(simdType, op1, intrinsicId, callJitType, simdSize);
@@ -8856,10 +8850,27 @@ GenTree* Compiler::impEstimateIntrinsic(CORINFO_METHOD_HANDLE method,
     }
 #endif // FEATURE_HW_INTRINSICS
 
-    // TODO-CQ: Returning this as an intrinsic blocks inlining and is undesirable
-    // return impMathIntrinsic(method, sig, callType, intrinsicName, tailCall);
+    switch (intrinsicName)
+    {
+        case NI_System_Math_ReciprocalEstimate:
+        case NI_System_Math_ReciprocalSqrtEstimate:
+        {
+            GenTree* op1 = impImplicitR4orR8Cast(impPopStack().val, callType);
 
-    return nullptr;
+            if (intrinsicName == NI_System_Math_ReciprocalSqrtEstimate)
+            {
+                op1 = new (this, GT_INTRINSIC)
+                    GenTreeIntrinsic(genActualType(callType), op1, NI_System_Math_Sqrt, nullptr);
+            }
+
+            return gtNewOperNode(GT_DIV, genActualType(callType), gtNewDconNode(1.0, callType), op1);
+        }
+
+        default:
+        {
+            unreached();
+        }
+    }
 }
 
 GenTree* Compiler::impMathIntrinsic(CORINFO_METHOD_HANDLE method,
@@ -8958,8 +8969,8 @@ GenTree* Compiler::impMinMaxIntrinsic(CORINFO_METHOD_HANDLE method,
     GenTreeDblCon* cnsNode   = nullptr;
     GenTree*       otherNode = nullptr;
 
-    GenTree* op2 = impStackTop().val;
-    GenTree* op1 = impStackTop(1).val;
+    GenTree* op2 = impImplicitR4orR8Cast(impStackTop().val, callType);
+    GenTree* op1 = impImplicitR4orR8Cast(impStackTop(1).val, callType);
 
     if (op2->IsCnsFltOrDbl())
     {
@@ -9227,7 +9238,7 @@ GenTree* Compiler::impMinMaxIntrinsic(CORINFO_METHOD_HANDLE method,
                     retNode->AsHWIntrinsic()->Op(2) = op1;
                 }
 
-                return gtNewSimdToScalarNode(callType, retNode, callJitType, 16);
+                return gtNewSimdToScalarNode(genActualType(callType), retNode, callJitType, 16);
             }
         }
 #endif // FEATURE_HW_INTRINSICS && TARGET_XARCH
@@ -9392,7 +9403,7 @@ GenTree* Compiler::impMinMaxIntrinsic(CORINFO_METHOD_HANDLE method,
                                            callJitType, 16);
         }
 
-        return gtNewSimdToScalarNode(callType, tmp, callJitType, 16);
+        return gtNewSimdToScalarNode(genActualType(callType), tmp, callJitType, 16);
     }
 #endif // FEATURE_HW_INTRINSICS && TARGET_XARCH
 

src/libraries/System.Private.CoreLib/src/System/Double.cs

@@ -866,10 +866,12 @@ bool IFloatingPoint<double>.TryWriteSignificandLittleEndian(Span<byte> destinati
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate(TSelf)" />
         [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
         public static double ReciprocalEstimate(double x) => Math.ReciprocalEstimate(x);
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate(TSelf)" />
         [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
         public static double ReciprocalSqrtEstimate(double x) => Math.ReciprocalSqrtEstimate(x);
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)" />

src/libraries/System.Private.CoreLib/src/System/Half.cs

@@ -1578,9 +1578,11 @@ public static int ILogB(Half x)
         public static Half Lerp(Half value1, Half value2, Half amount) => (Half)float.Lerp((float)value1, (float)value2, (float)amount);
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate(TSelf)" />
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
         public static Half ReciprocalEstimate(Half x) => (Half)MathF.ReciprocalEstimate((float)x);
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate(TSelf)" />
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
         public static Half ReciprocalSqrtEstimate(Half x) => (Half)MathF.ReciprocalSqrtEstimate((float)x);
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)" />

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

@@ -1195,12 +1195,13 @@ public static double MinMagnitude(double x, double y)
         ///    <para>On ARM64 hardware this may use the <c>FRECPE</c> instruction which performs a single Newton-Raphson iteration.</para>
         ///    <para>On hardware without specialized support, this may just return <c>1.0 / d</c>.</para>
         /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+#if MONO
+        public static double ReciprocalEstimate(double d) => 1.0 / d;
+#else
         [Intrinsic]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double ReciprocalEstimate(double d)
-        {
-            return 1.0 / d;
-        }
+        public static double ReciprocalEstimate(double d) => ReciprocalEstimate(d);
+#endif
 
         /// <summary>Returns an estimate of the reciprocal square root of a specified number.</summary>
         /// <param name="d">The number whose reciprocal square root is to be estimated.</param>
@@ -1209,12 +1210,13 @@ public static double ReciprocalEstimate(double d)
         ///    <para>On ARM64 hardware this may use the <c>FRSQRTE</c> instruction which performs a single Newton-Raphson iteration.</para>
         ///    <para>On hardware without specialized support, this may just return <c>1.0 / Sqrt(d)</c>.</para>
         /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+#if MONO || TARGET_RISCV64 || TARGET_LOONGARCH64
+        public static double ReciprocalSqrtEstimate(double d) => 1.0 / Sqrt(d);
+#else
         [Intrinsic]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double ReciprocalSqrtEstimate(double d)
-        {
-            return 1.0 / Sqrt(d);
-        }
+        public static double ReciprocalSqrtEstimate(double d) => ReciprocalSqrtEstimate(d);
+#endif
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static decimal Round(decimal d)

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

@@ -313,12 +313,13 @@ public static float MinMagnitude(float x, float y)
         ///    <para>On ARM64 hardware this may use the <c>FRECPE</c> instruction which performs a single Newton-Raphson iteration.</para>
         ///    <para>On hardware without specialized support, this may just return <c>1.0 / x</c>.</para>
         /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+#if MONO
+        public static float ReciprocalEstimate(float x) => 1.0f / x;
+#else
         [Intrinsic]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float ReciprocalEstimate(float x)
-        {
-            return 1.0f / x;
-        }
+        public static float ReciprocalEstimate(float x) => ReciprocalEstimate(x);
+#endif
 
         /// <summary>Returns an estimate of the reciprocal square root of a specified number.</summary>
         /// <param name="x">The number whose reciprocal square root is to be estimated.</param>
@@ -328,12 +329,13 @@ public static float ReciprocalEstimate(float x)
         ///    <para>On ARM64 hardware this may use the <c>FRSQRTE</c> instruction which performs a single Newton-Raphson iteration.</para>
         ///    <para>On hardware without specialized support, this may just return <c>1.0 / Sqrt(x)</c>.</para>
         /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+#if MONO || TARGET_RISCV64 || TARGET_LOONGARCH64
+        public static float ReciprocalSqrtEstimate(float x) => 1.0f / Sqrt(x);
+#else
         [Intrinsic]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float ReciprocalSqrtEstimate(float x)
-        {
-            return 1.0f / Sqrt(x);
-        }
+        public static float ReciprocalSqrtEstimate(float x) => ReciprocalSqrtEstimate(x);
+#endif
 
         [Intrinsic]
         public static float Round(float x)

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NFloat.cs

@@ -1190,9 +1190,11 @@ bool IFloatingPoint<NFloat>.TryWriteSignificandLittleEndian(Span<byte> destinati
         public static NFloat Lerp(NFloat value1, NFloat value2, NFloat amount) => new NFloat(NativeType.Lerp(value1._value, value2._value, amount._value));
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate(TSelf)" />
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
         public static NFloat ReciprocalEstimate(NFloat x) => new NFloat(NativeType.ReciprocalEstimate(x._value));
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate(TSelf)" />
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
         public static NFloat ReciprocalSqrtEstimate(NFloat x) => new NFloat(NativeType.ReciprocalSqrtEstimate(x._value));
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)" />

src/libraries/System.Private.CoreLib/src/System/Single.cs

@@ -849,10 +849,12 @@ bool IFloatingPoint<float>.TryWriteSignificandLittleEndian(Span<byte> destinatio
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate(TSelf)" />
         [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
         public static float ReciprocalEstimate(float x) => MathF.ReciprocalEstimate(x);
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate(TSelf)" />
         [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
         public static float ReciprocalSqrtEstimate(float x) => MathF.ReciprocalSqrtEstimate(x);
 
         /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)" />