JIT: Evaluate GDV call args early

src/coreclr/jit/indirectcalltransformer.cpp

@@ -540,28 +540,39 @@ class IndirectCallTransformer
             checkBlock             = currBlock;
             checkBlock->bbJumpKind = BBJ_COND;
 
-            CallArg* thisArg  = origCall->gtArgs.GetThisArg();
-            GenTree* thisTree = thisArg->GetNode();
-
-            // Create temp for this if the tree is costly.
-            if (thisTree->IsLocal())
-            {
-                thisTree = compiler->gtCloneExpr(thisTree);
-            }
-            else
+            // The guard is going to dereference 'this'. This needs to happen
+            // after arguments have been evaluated if 'this' may be null, so we
+            // have to spill all arguments with side effects.
+            for (CallArg& arg : origCall->gtArgs.Args())
             {
-                const unsigned thisTempNum = compiler->lvaGrabTemp(true DEBUGARG("guarded devirt this temp"));
-                GenTree*       asgTree     = compiler->gtNewTempAssign(thisTempNum, thisTree);
-                Statement*     asgStmt     = compiler->fgNewStmtFromTree(asgTree, stmt->GetDebugInfo());
-                compiler->fgInsertStmtAtEnd(checkBlock, asgStmt);
+                bool     spill   = false;
+                GenTree* argNode = arg.GetNode();
 
-                thisTree = compiler->gtNewLclvNode(thisTempNum, TYP_REF);
+                if (arg.GetWellKnownArg() == WellKnownArg::ThisPointer)
+                {
+                    // Guard is going to access this arg, spill it if it is
+                    // complex, regardless of side effects.
+                    spill = !argNode->IsLocal();
+                }
+                else
+                {
+                    spill = (argNode->gtFlags & GTF_SIDE_EFFECT) != 0;
+                }
+
+                if (spill)
+                {
+                    unsigned   tmpNum  = compiler->lvaGrabTemp(true DEBUGARG("guarded devirt arg temp"));
+                    GenTree*   asgTree = compiler->gtNewTempAssign(tmpNum, argNode);
+                    Statement* asgStmt = compiler->fgNewStmtFromTree(asgTree, stmt->GetDebugInfo());
+                    compiler->fgInsertStmtAtEnd(checkBlock, asgStmt);
 
-                // Propagate the new this to the call. Must be a new expr as the call
-                // will live on in the else block and thisTree is used below.
-                thisArg->SetEarlyNode(compiler->gtNewLclvNode(thisTempNum, TYP_REF));
+                    arg.SetEarlyNode(compiler->gtNewLclvNode(tmpNum, genActualType(argNode)));
+                }
             }
 
+            CallArg* thisArg  = origCall->gtArgs.GetThisArg();
+            GenTree* thisTree = compiler->gtCloneExpr(thisArg->GetNode());
+
             // Remember the current last statement. If we're doing a chained GDV, we'll clone/copy
             // all the code in the check block up to and including this statement.
             //

src/tests/JIT/Regression/JitBlue/Runtime_75607/Runtime_75607.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+public class Program
+{
+    private static int s_result;
+    public static int Main()
+    {
+        C c = new();
+        for (int i = 0; i < 100; i++)
+        {
+            Foo(c);
+            Thread.Sleep(15);
+        }
+
+        s_result = -1;
+        try
+        {
+            Foo(null);
+            Console.WriteLine("FAIL: No exception thrown");
+            return -2;
+        }
+        catch (NullReferenceException)
+        {
+            if (s_result == 100)
+            {
+                Console.WriteLine("PASS");
+            }
+            else
+            {
+                Console.WriteLine("FAIL: Result is {0}", s_result);
+            }
+
+            return s_result;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void Foo(Base b)
+    {
+        b.Test(SideEffect(10));
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static long SideEffect(long i)
+    {
+        s_result = 100;
+        return i;
+    }
+}
+
+public interface Base
+{
+    void Test(long arg);
+}
+
+public class C : Base
+{
+    public void Test(long arg)
+    {
+    }
+}

src/tests/JIT/Regression/JitBlue/Runtime_75607/Runtime_75607.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+  <PropertyGroup>
+    <CLRTestBatchPreCommands><![CDATA[
+$(CLRTestBatchPreCommands)
+set COMPlus_TieredPGO=1
+set COMPlus_TC_QuickJitForLoops=1
+]]></CLRTestBatchPreCommands>
+    <BashCLRTestPreCommands><![CDATA[
+$(BashCLRTestPreCommands)
+export COMPlus_TieredPGO=1
+export COMPlus_TC_QuickJitForLoops=1
+]]></BashCLRTestPreCommands>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+  </ItemGroup>
+</Project>