Use proper context in initClass for GDV

src/coreclr/jit/compiler.h

@@ -7152,12 +7152,13 @@ class Compiler
 
     bool isCompatibleMethodGDV(GenTreeCall* call, CORINFO_METHOD_HANDLE gdvTarget);
 
-    void addGuardedDevirtualizationCandidate(GenTreeCall*          call,
-                                             CORINFO_METHOD_HANDLE methodHandle,
-                                             CORINFO_CLASS_HANDLE  classHandle,
-                                             unsigned              methodAttr,
-                                             unsigned              classAttr,
-                                             unsigned              likelihood);
+    void addGuardedDevirtualizationCandidate(GenTreeCall*           call,
+                                             CORINFO_METHOD_HANDLE  methodHandle,
+                                             CORINFO_CLASS_HANDLE   classHandle,
+                                             CORINFO_CONTEXT_HANDLE contextHandle,
+                                             unsigned               methodAttr,
+                                             unsigned               classAttr,
+                                             unsigned               likelihood);
 
     int getGDVMaxTypeChecks()
     {

src/coreclr/jit/importercalls.cpp

@@ -5931,8 +5931,8 @@ void Compiler::considerGuardedDevirtualization(GenTreeCall*            call,
                     likelyHood += 100 - likelyHood * numExactClasses;
                 }
 
-                addGuardedDevirtualizationCandidate(call, exactMethod, exactCls, exactMethodAttrs, clsAttrs,
-                                                    likelyHood);
+                addGuardedDevirtualizationCandidate(call, exactMethod, exactCls, dvInfo.exactContext, exactMethodAttrs,
+                                                    clsAttrs, likelyHood);
             }
 
             if (call->GetInlineCandidatesCount() == numExactClasses)
@@ -5959,6 +5959,8 @@ void Compiler::considerGuardedDevirtualization(GenTreeCall*            call,
         CORINFO_METHOD_HANDLE likelyMethod = likelyMethodes[candidateId];
         unsigned              likelihood   = likelihoods[candidateId];
 
+        CORINFO_CONTEXT_HANDLE likelyContext = NULL;
+
         uint32_t likelyClassAttribs = 0;
         if (likelyClass != NO_CLASS_HANDLE)
         {
@@ -5993,8 +5995,8 @@ void Compiler::considerGuardedDevirtualization(GenTreeCall*            call,
                 // Continue checking other candidates, maybe some of them will succeed.
                 break;
             }
-
-            likelyMethod = dvInfo.devirtualizedMethod;
+            likelyContext = dvInfo.exactContext;
+            likelyMethod  = dvInfo.devirtualizedMethod;
         }
 
         uint32_t likelyMethodAttribs = info.compCompHnd->getMethodAttribs(likelyMethod);
@@ -6062,8 +6064,8 @@ void Compiler::considerGuardedDevirtualization(GenTreeCall*            call,
 
         // Add this as a potential candidate.
         //
-        addGuardedDevirtualizationCandidate(call, likelyMethod, likelyClass, likelyMethodAttribs, likelyClassAttribs,
-                                            likelihood);
+        addGuardedDevirtualizationCandidate(call, likelyMethod, likelyClass, likelyContext, likelyMethodAttribs,
+                                            likelyClassAttribs, likelihood);
     }
 }
 
@@ -6088,12 +6090,13 @@ void Compiler::considerGuardedDevirtualization(GenTreeCall*            call,
 //    classAttr - attributes of the class
 //    likelihood - odds that this class is the class seen at runtime
 //
-void Compiler::addGuardedDevirtualizationCandidate(GenTreeCall*          call,
-                                                   CORINFO_METHOD_HANDLE methodHandle,
-                                                   CORINFO_CLASS_HANDLE  classHandle,
-                                                   unsigned              methodAttr,
-                                                   unsigned              classAttr,
-                                                   unsigned              likelihood)
+void Compiler::addGuardedDevirtualizationCandidate(GenTreeCall*           call,
+                                                   CORINFO_METHOD_HANDLE  methodHandle,
+                                                   CORINFO_CLASS_HANDLE   classHandle,
+                                                   CORINFO_CONTEXT_HANDLE contextHandle,
+                                                   unsigned               methodAttr,
+                                                   unsigned               classAttr,
+                                                   unsigned               likelihood)
 {
     // This transformation only makes sense for delegate and virtual calls
     assert(call->IsDelegateInvoke() || call->IsVirtual());
@@ -6166,6 +6169,7 @@ void Compiler::addGuardedDevirtualizationCandidate(GenTreeCall*          call,
     pInfo->guardedClassHandle              = classHandle;
     pInfo->likelihood                      = likelihood;
     pInfo->requiresInstMethodTableArg      = false;
+    pInfo->exactContextHnd                 = contextHandle;
 
     // If the guarded class is a value class, look for an unboxed entry point.
     //
@@ -7754,10 +7758,16 @@ void Compiler::impCheckCanInline(GenTreeCall*           call,
                 return;
             }
 
+            CORINFO_CONTEXT_HANDLE exactContext = pParam->exactContextHnd;
+            if (pParam->call->IsGuardedDevirtualizationCandidate())
+            {
+                exactContext = pParam->call->GetGDVCandidateInfo(pParam->candidateIndex)->exactContextHnd;
+            }
+
             // Speculatively check if initClass() can be done.
             // If it can be done, we will try to inline the method.
             CorInfoInitClassResult const initClassResult =
-                compCompHnd->initClass(nullptr /* field */, ftn /* method */, pParam->exactContextHnd /* context */);
+                compCompHnd->initClass(nullptr /* field */, ftn /* method */, exactContext /* context */);
 
             if (initClassResult & CORINFO_INITCLASS_DONT_INLINE)
             {

src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp

@@ -1015,12 +1015,6 @@ CorInfoInitClassResult MethodContext::repInitClass(CORINFO_FIELD_HANDLE   field,
     key.method  = CastHandle(method);
     key.context = CastHandle(context);
 
-    if ((InitClass == nullptr) || (InitClass->GetIndex(key) == -1))
-    {
-        // We could try additional inlines with stress modes, just reject them.
-        return CORINFO_INITCLASS_DONT_INLINE;
-    }
-
     DWORD value = InitClass->Get(key);
     DEBUG_REP(dmpInitClass(key, value));
     CorInfoInitClassResult result = (CorInfoInitClassResult)value;

src/coreclr/vm/jitinterface.cpp

@@ -8425,22 +8425,22 @@ bool CEEInfo::resolveVirtualMethodHelper(CORINFO_DEVIRTUALIZATION_INFO * info)
         return false;
     }
 
-    if (pBaseMT->IsInterface())
-    {
-
 #ifdef FEATURE_COMINTEROP
-        // Don't try and devirtualize com interface calls.
-        if (pObjMT->IsComObjectType())
-        {
-            info->detail = CORINFO_DEVIRTUALIZATION_FAILED_COM;
-            return false;
-        }
+    // Don't try and devirtualize com interface calls.
+    if (pBaseMT->IsInterface() && pObjMT->IsComObjectType())
+    {
+        info->detail = CORINFO_DEVIRTUALIZATION_FAILED_COM;
+        return false;
+    }
 #endif // FEATURE_COMINTEROP
 
-        if (info->context != nullptr)
-        {
-            pBaseMT = GetTypeFromContext(info->context).GetMethodTable();
-        }
+    if (info->context != nullptr)
+    {
+        pBaseMT = GetTypeFromContext(info->context).GetMethodTable();
+    }
+
+    if (pBaseMT->IsInterface())
+    {
 
         // Interface call devirtualization.
         //