Change the ReciprocalEstimate and ReciprocalSqrtEstimate APIs to be mustExpand on RyuJIT

src/coreclr/jit/hwintrinsicarm64.cpp

@@ -624,10 +624,20 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
-        case NI_Vector64_ConvertToInt32:
         case NI_Vector64_ConvertToInt32Native:
-        case NI_Vector128_ConvertToInt32:
         case NI_Vector128_ConvertToInt32Native:
+        {
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                break;
+            }
+            FALLTHROUGH;
+        }
+
+        case NI_Vector64_ConvertToInt32:
+        case NI_Vector128_ConvertToInt32:
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_FLOAT);
@@ -637,10 +647,20 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
-        case NI_Vector64_ConvertToInt64:
         case NI_Vector64_ConvertToInt64Native:
-        case NI_Vector128_ConvertToInt64:
         case NI_Vector128_ConvertToInt64Native:
+        {
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                break;
+            }
+            FALLTHROUGH;
+        }
+
+        case NI_Vector64_ConvertToInt64:
+        case NI_Vector128_ConvertToInt64:
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_DOUBLE);
@@ -661,10 +681,20 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
-        case NI_Vector64_ConvertToUInt32:
         case NI_Vector64_ConvertToUInt32Native:
-        case NI_Vector128_ConvertToUInt32:
         case NI_Vector128_ConvertToUInt32Native:
+        {
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                break;
+            }
+            FALLTHROUGH;
+        }
+
+        case NI_Vector64_ConvertToUInt32:
+        case NI_Vector128_ConvertToUInt32:
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_FLOAT);
@@ -674,10 +704,20 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
-        case NI_Vector64_ConvertToUInt64:
         case NI_Vector64_ConvertToUInt64Native:
-        case NI_Vector128_ConvertToUInt64:
         case NI_Vector128_ConvertToUInt64Native:
+        {
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                break;
+            }
+            FALLTHROUGH;
+        }
+
+        case NI_Vector64_ConvertToUInt64:
+        case NI_Vector128_ConvertToUInt64:
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_DOUBLE);

src/coreclr/jit/hwintrinsicxarch.cpp

@@ -1436,6 +1436,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_FLOAT);
 
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                break;
+            }
+
             op1     = impSIMDPopStack();
             retNode = gtNewSimdCvtNativeNode(retType, op1, CORINFO_TYPE_INT, simdBaseJitType, simdSize);
             break;
@@ -1463,6 +1470,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_DOUBLE);
 
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                break;
+            }
+
             if (IsBaselineVector512IsaSupportedOpportunistically())
             {
                 op1     = impSIMDPopStack();
@@ -1542,6 +1556,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_FLOAT);
 
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                break;
+            }
+
             if (IsBaselineVector512IsaSupportedOpportunistically())
             {
                 op1     = impSIMDPopStack();
@@ -1556,6 +1577,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_DOUBLE);
+
             if (IsBaselineVector512IsaSupportedOpportunistically())
             {
                 op1     = impSIMDPopStack();
@@ -1571,6 +1593,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             assert(sig->numArgs == 1);
             assert(simdBaseType == TYP_DOUBLE);
 
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                break;
+            }
+
             if (IsBaselineVector512IsaSupportedOpportunistically())
             {
                 op1     = impSIMDPopStack();

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)
         {
@@ -5199,8 +5191,18 @@ GenTree* Compiler::impPrimitiveNamedIntrinsic(NamedIntrinsic        intrinsic,
 
     switch (intrinsic)
     {
-        case NI_PRIMITIVE_ConvertToInteger:
         case NI_PRIMITIVE_ConvertToIntegerNative:
+        {
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                return nullptr;
+            }
+            FALLTHROUGH;
+        }
+
+        case NI_PRIMITIVE_ConvertToInteger:
         {
             assert(sig->sigInst.methInstCount == 1);
             assert(varTypeIsFloating(baseType));
@@ -7471,6 +7473,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:
@@ -8771,10 +8775,16 @@ GenTree* Compiler::impEstimateIntrinsic(CORINFO_METHOD_HANDLE method,
     assert(varTypeIsFloating(callType));
     assert(sig->numArgs == 1);
 
+    if (opts.IsReadyToRun())
+    {
+        // We explicitly block these APIs from being expanded in R2R
+        // since we know they are non-deterministic across hardware
+        return nullptr;
+    }
+
 #if defined(FEATURE_HW_INTRINSICS)
     // We use compExactlyDependsOn since these are estimate APIs where
-    // the behavior is explicitly allowed to differ across machines and
-    // we want to ensure that it gets marked as such in R2R.
+    // the behavior is explicitly allowed to differ across machines
 
     var_types      simdType    = TYP_UNKNOWN;
     NamedIntrinsic intrinsicId = NI_Illegal;
@@ -8847,7 +8857,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 +8866,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 +8985,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 +9254,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 +9419,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/coreclr/jit/simdashwintrinsic.cpp

@@ -512,8 +512,39 @@ GenTree* Compiler::impSimdAsHWIntrinsicSpecial(NamedIntrinsic       intrinsic,
 
     switch (intrinsic)
     {
+        case NI_VectorT_ConvertToInt32Native:
+        {
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                return nullptr;
+            }
+            break;
+        }
+
+        case NI_VectorT_ConvertToInt64Native:
+        case NI_VectorT_ConvertToUInt32Native:
+        case NI_VectorT_ConvertToUInt64Native:
+        {
+            if (opts.IsReadyToRun())
+            {
+                // We explicitly block these APIs from being expanded in R2R
+                // since we know they are non-deterministic across hardware
+                return nullptr;
+            }
+
 #if defined(TARGET_XARCH)
+            if (!IsBaselineVector512IsaSupportedOpportunistically())
+            {
+                return nullptr;
+            }
+#endif // TARGET_XARCH
 
+            break;
+        }
+
+#if defined(TARGET_XARCH)
         case NI_VectorT_ConvertToDouble:
         {
             if (IsBaselineVector512IsaSupportedOpportunistically())
@@ -533,11 +564,8 @@ GenTree* Compiler::impSimdAsHWIntrinsicSpecial(NamedIntrinsic       intrinsic,
         }
 
         case NI_VectorT_ConvertToInt64:
-        case NI_VectorT_ConvertToInt64Native:
         case NI_VectorT_ConvertToUInt32:
-        case NI_VectorT_ConvertToUInt32Native:
         case NI_VectorT_ConvertToUInt64:
-        case NI_VectorT_ConvertToUInt64Native:
         {
             if (IsBaselineVector512IsaSupportedOpportunistically())
             {

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -800,6 +800,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Resources\SatelliteContractVersionAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Resources\UltimateResourceFallbackLocation.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\AmbiguousImplementationException.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\BypassReadyToRunAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\AccessedThroughPropertyAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\AsyncIteratorMethodBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\AsyncIteratorStateMachineAttribute.cs" />

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

@@ -6,6 +6,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Numerics;
+using System.Runtime;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
@@ -662,6 +663,7 @@ public static TInteger ConvertToInteger<TInteger>(double value)
 
         /// <inheritdoc cref="IFloatingPoint{TSelf}.ConvertToIntegerNative{TInteger}(TSelf)" />
         [Intrinsic]
+        [BypassReadyToRun]
         public static TInteger ConvertToIntegerNative<TInteger>(double value)
             where TInteger : IBinaryInteger<TInteger> => TInteger.CreateSaturating(value);