JIT: Devirtualize generic virtual methods

[hez2010]

Enable devirtualization support for generic virtual methods.

When we see a base method having a method instantiation, we use FindOrCreateAssociatedMethodDesc to obtain the devirted method.

If we end up with an instantiating stub (i.e. a generic method that requires runtime lookup), we will need:

• Insert the runtime lookup node as the inst param if we have a runtime lookup node (we implemented the runtime lookup in this way, so the runtime method handle argument must be a RUNTIMELOOKUP node if it requires a runtime lookup. see

  runtime/src/coreclr/jit/importer.cpp

  Line 1341 in 3b63772

  result = gtNewRuntimeLookup(embedInfo.compileTimeHandle, embedInfo.handleType, result);

  )
• Otherwise, we can insert the instantiating stub as the inst param

Also introduced a jit knob so that it can be turned off at any time.

AOT support is not included in this PR, which needs additional work in managed type system.

Also, devirting a generic virtual method to a class that has a different generic type context is not yet supported, I would like to leave it for future improvement:

For example, let's say we have a

class Base
{
    public abstract void M<U>();
}
class Derived<T> : Base
{
    public override void M<U>() { ... }
}

and we managed to devirt Base.M<string> into Derived<SomeClass>.M<string>. Here in order to call M, we need to do a runtime lookup, but the context being used for runtime lookup only contains the information of method instantiations, so if we continue to use this context, we will miss the class instantiations because we don't have the right context here. Similar issue also exists for cases like devirting Base<Class1>.M<string> to Derived<Class2>.M<string>, which can result in incorrect class instantiations.
To resolve this, we need to replace the generic context handle used for runtime lookup with the right one that has both the class instantiations and the method instantiations of the devirted method. In my analysis resolving this will unblock many devirt opportunities for PLINQ.

---

Codegen example:

public class IntProcessor : VirtualGenericClass, IVritualGenericInterface
{
    public override void Process<T>(T item)
    {
        Console.WriteLine(item.ToString());
    }
}

public interface IVritualGenericInterface
{
    void Process<T>(T item) where T : notnull;
}

public static void Test<T>(IVritualGenericInterface ifce, T item) where T : notnull
{
    ifce.Process(item);
}

public static void Test<T>(VirtualGenericClass baseClass, T item) where T : notnull
{
    baseClass.Process(item);
}

static void Test()
{
    IVritualGenericInterface i = new IntProcessor();
    Test(i, 42);
    Test(i, "test");

    VirtualGenericClass c = new IntProcessor();
    Test(c, 42);
    Test(c, "test");
}

Codegen diff:

  G_M24707_IG01:  ;; offset=0x0000
-        push     rdi
-        push     rsi
-        push     rbp
         push     rbx
-        sub      rsp, 40
-                                                 ;; size=8 bbWeight=1 PerfScore 4.25
- G_M24707_IG02:  ;; offset=0x0008
-        mov      rbx, 0x7FFC21E046E0      ; Program+IntProcessor
-        mov      rcx, rbx
-        call     CORINFO_HELP_NEWSFAST
-        mov      rsi, rax
-        mov      rcx, rsi
-        mov      rdi, 0x7FFC21E044C8      ; Program+IVritualGenericInterface
-        mov      rdx, rdi
-        mov      r8, 0x7FFC21E04EA0      ; token handle
-        call     CORINFO_HELP_VIRTUAL_FUNC_PTR
-        mov      rcx, rsi
-        mov      edx, 42
-        call     rax
-        mov      rbp, 0x1AC49ACE518      ; 'test'
-        mov      rcx, rsi
-        mov      rdx, rdi
-        mov      r8, 0x7FFC21E051C0      ; token handle
-        call     CORINFO_HELP_VIRTUAL_FUNC_PTR
-        mov      rcx, rsi
-        mov      rdx, rbp
-        call     rax
-        mov      rcx, rbx
-        call     CORINFO_HELP_NEWSFAST
-        mov      rbx, rax
-        mov      rcx, rbx
-        mov      rsi, 0x7FFC21E042F8      ; Program+VirtualGenericClass
-        mov      rdx, rsi
-        mov      r8, 0x7FFC21E052B8      ; token handle
-        call     CORINFO_HELP_VIRTUAL_FUNC_PTR
-        mov      rcx, rbx
-        mov      edx, 42
-        call     rax
+        sub      rsp, 32
+                                                 ;; size=5 bbWeight=1 PerfScore 1.25
+ G_M24707_IG02:  ;; offset=0x0005
+        mov      ecx, 42
+        call     [System.Number:Int32ToDecStr(int):System.String]
+        mov      rcx, rax
+        call     [System.Console:WriteLine(System.String)]
+        mov      rbx, 0x1E66CB8E518      ; 'test'
         mov      rcx, rbx
-        mov      rdx, rsi
-        mov      r8, 0x7FFC21E055D8      ; token handle
-        call     CORINFO_HELP_VIRTUAL_FUNC_PTR
+        call     [System.Console:WriteLine(System.String)]
+        mov      ecx, 42
+        call     [System.Number:Int32ToDecStr(int):System.String]
+        mov      rcx, rax
+        call     [System.Console:WriteLine(System.String)]
         mov      rcx, rbx
-        mov      rdx, rbp
-        call     rax
+        call     [System.Console:WriteLine(System.String)]
         nop
-                                                 ;; size=183 bbWeight=1 PerfScore 25.25
- G_M24707_IG03:  ;; offset=0x00BF
-        add      rsp, 40
+                                                 ;; size=69 bbWeight=1 PerfScore 20.00
+ G_M24707_IG03:  ;; offset=0x004A
+        add      rsp, 32
         pop      rbx
-        pop      rbp
-        pop      rsi
-        pop      rdi
         ret
-                                                 ;; size=9 bbWeight=1 PerfScore 3.25
+                                                 ;; size=6 bbWeight=1 PerfScore 1.75

Contributes to #112596

cc: @dotnet/jit-contrib

[Copilot]

Pull request overview

This PR enables devirtualization support for generic virtual methods in the JIT compiler, allowing calls to generic virtual methods to be devirtualized when the exact type is known at JIT time. This optimization eliminates virtual dispatch overhead and enables further optimizations like inlining.

Key changes:

• Removes the assertion that previously blocked generic method devirtualization
• Generalizes array interface devirtualization to support generic virtual methods by renaming wasArrayInterfaceDevirt to needsMethodContext
• Adds runtime lookup support for generic method instantiation parameters

Reviewed changes

Copilot reviewed 13 out of 13 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
src/coreclr/vm/jitinterface.cpp	Removes assertion blocking generic method devirtualization and adds logic to handle generic virtual methods using FindOrCreateAssociatedMethodDesc
src/coreclr/inc/corinfo.h	Renames wasArrayInterfaceDevirt to needsMethodContext to generalize the field meaning
src/coreclr/jit/jitconfigvalues.h	Adds JitEnableGenericVirtualDevirtualization configuration flag to control the feature
src/coreclr/jit/gentree.h	Adds IsGenericVirtual() helper method to identify generic virtual method calls
src/coreclr/jit/gentree.cpp	Updates IsDevirtualizationCandidate() to include generic virtual methods (non-AOT only)
src/coreclr/jit/importercalls.cpp	Implements devirtualization logic for generic virtual methods including runtime lookup handling, updates comments and variable names, and introduces DEVIRT label for control flow
src/coreclr/jit/inline.h	Renames arrayInterface field to needsMethodContext in InlineCandidateInfo struct
src/coreclr/jit/indirectcalltransformer.cpp	Updates to use renamed needsMethodContext field
src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs	Updates managed struct definition to match renamed field
src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs	Updates to use renamed field in managed implementation
src/coreclr/tools/superpmi/superpmi-shared/agnostic.h	Updates SuperPMI data structure with renamed field
src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp	Updates SuperPMI recording/replay to use renamed field

[hez2010]

@MihuBot

[jakobbotsch]

Can you explain this behavior?

It mixes syntax and semantics. Nothing guarantees that a runtime lookup appears as a GT_RUNTIMELOOKUP node. It could have been stored to a local and a number of other things.

[hez2010]

Pushed a new commit including comments to clarify this behavior. Also updated the description of the PR.

[hez2010]

@MihuBot
Just check again to make sure we properly preserved the runtime lookup calls for shared generics.

[hez2010]

I think it's ready for review now.