Virtual stub indirect call profiling (#116453)

AndyAyersMS · web-flow · commit 39a31f082e77 · 2025-06-16T17:35:31.000-07:00
Add support for profiling indirect virtual stub calls and subsequent guarded devirtualization.
diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h
@@ -11886,7 +11886,7 @@ class GenTreeVisitor
 
                 if (call->gtCallType == CT_INDIRECT)
                 {
-                    if (call->gtCallCookie != nullptr)
+                    if (!call->IsVirtualStub() && (call->gtCallCookie != nullptr))
                     {
                         result = WalkTree(&call->gtCallCookie, call);
                         if (result == fgWalkResult::WALK_ABORT)
diff --git a/src/coreclr/jit/compiler.hpp b/src/coreclr/jit/compiler.hpp
@@ -4683,7 +4683,8 @@ void GenTree::VisitOperands(TVisitor visitor)
 
             if (call->gtCallType == CT_INDIRECT)
             {
-                if ((call->gtCallCookie != nullptr) && (visitor(call->gtCallCookie) == VisitResult::Abort))
+                if (!call->IsVirtualStub() && (call->gtCallCookie != nullptr) &&
+                    (visitor(call->gtCallCookie) == VisitResult::Abort))
                 {
                     return;
                 }
diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
@@ -5977,7 +5977,9 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)
             if (call->gtCallType == CT_INDIRECT)
             {
                 // pinvoke-calli cookie is a constant, or constant indirection
-                assert(call->gtCallCookie == nullptr || call->gtCallCookie->OperIs(GT_CNS_INT, GT_IND));
+                // or a non-tree if this is a managed call.
+                assert(call->IsVirtualStub() || (call->gtCallCookie == nullptr) ||
+                       call->gtCallCookie->OperIs(GT_CNS_INT, GT_IND));
 
                 GenTree* indirect = call->gtCallAddr;
 
@@ -6725,7 +6727,7 @@ bool GenTree::TryGetUse(GenTree* operand, GenTree*** pUse)
             }
             if (call->gtCallType == CT_INDIRECT)
             {
-                if (operand == call->gtCallCookie)
+                if (!call->IsVirtualStub() && (operand == call->gtCallCookie))
                 {
                     *pUse = &call->gtCallCookie;
                     return true;
@@ -9899,16 +9901,23 @@ GenTreeCall* Compiler::gtCloneExprCallHelper(GenTreeCall* tree)
     /* Copy the union */
     if (tree->gtCallType == CT_INDIRECT)
     {
-        copy->gtCallCookie = tree->gtCallCookie ? gtCloneExpr(tree->gtCallCookie) : nullptr;
-        copy->gtCallAddr   = tree->gtCallAddr ? gtCloneExpr(tree->gtCallAddr) : nullptr;
+        if (tree->IsVirtualStub())
+        {
+            copy->gtCallCookie = tree->gtCallCookie;
+        }
+        else
+        {
+            copy->gtCallCookie = tree->gtCallCookie ? gtCloneExpr(tree->gtCallCookie) : nullptr;
+        }
+        copy->gtCallAddr = tree->gtCallAddr ? gtCloneExpr(tree->gtCallAddr) : nullptr;
     }
     else
     {
         copy->gtCallMethHnd         = tree->gtCallMethHnd;
         copy->gtInlineCandidateInfo = tree->gtInlineCandidateInfo;
-        copy->gtInlineInfoCount     = tree->gtInlineInfoCount;
     }
 
+    copy->gtInlineInfoCount          = tree->gtInlineInfoCount;
     copy->gtLateDevirtualizationInfo = tree->gtLateDevirtualizationInfo;
 
     copy->gtCallType   = tree->gtCallType;
@@ -10641,7 +10650,7 @@ void GenTreeUseEdgeIterator::AdvanceCall()
             assert(call->gtCallType == CT_INDIRECT);
 
             m_advance = &GenTreeUseEdgeIterator::AdvanceCall<CALL_ADDRESS>;
-            if (call->gtCallCookie != nullptr)
+            if (!call->IsVirtualStub() && (call->gtCallCookie != nullptr))
             {
                 m_edge = &call->gtCallCookie;
                 return;
@@ -10964,6 +10973,11 @@ void Compiler::gtDispNodeName(GenTree* tree)
         }
         else if (tree->AsCall()->gtCallType == CT_INDIRECT)
         {
+            if (tree->AsCall()->IsVirtual())
+            {
+                callType = "CALLV";
+            }
+
             ctType = " ind";
         }
         else
diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp
@@ -6935,8 +6935,20 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     {
                         JITDUMP(".... checking for GDV of IEnumerable<T>...\n");
 
-                        GenTreeCall* const   call = op1->AsRetExpr()->gtInlineCandidate;
-                        NamedIntrinsic const ni   = lookupNamedIntrinsic(call->gtCallMethHnd);
+                        GenTreeCall* const call = op1->AsRetExpr()->gtInlineCandidate;
+                        NamedIntrinsic     ni   = NI_Illegal;
+
+                        // TODO -- handle CT_INDIRECT virtuals here too
+                        // but we don't have the right method handle
+                        //
+                        if (call->gtCallType == CT_USER_FUNC)
+                        {
+                            ni = lookupNamedIntrinsic(call->gtCallMethHnd);
+                        }
+                        else if (call->IsGuardedDevirtualizationCandidate())
+                        {
+                            JITDUMP("No GDV IEnumerable<T> check for [%06u]\n", dspTreeID(call));
+                        }
 
                         if (ni == NI_System_Collections_Generic_IEnumerable_GetEnumerator)
                         {
diff --git a/src/coreclr/jit/importercalls.cpp b/src/coreclr/jit/importercalls.cpp
@@ -7276,7 +7276,8 @@ void Compiler::considerGuardedDevirtualization(GenTreeCall*            call,
 
             if (!canResolve)
             {
-                JITDUMP("Can't figure out which method would be invoked, sorry\n");
+                JITDUMP("Can't figure out which method would be invoked, sorry. [%s]\n",
+                        devirtualizationDetailToString(dvInfo.detail));
 
                 // Continue checking other candidates, maybe some of them will succeed.
                 break;
@@ -7695,20 +7696,28 @@ void Compiler::impMarkInlineCandidateHelper(GenTreeCall*           call,
         }
     }
 
-    /* Ignore helper calls */
-
+    // Ignore helper calls
+    //
     if (call->IsHelperCall())
     {
         assert(!call->IsGuardedDevirtualizationCandidate());
         inlineResult->NoteFatal(InlineObservation::CALLSITE_IS_CALL_TO_HELPER);
         return;
     }
 
-    /* Ignore indirect calls */
+    // Ignore indirect calls, unless they are indirect virtual stub calls with profile info.
+    //
     if (call->gtCallType == CT_INDIRECT)
     {
-        inlineResult->NoteFatal(InlineObservation::CALLSITE_IS_NOT_DIRECT_MANAGED);
-        return;
+        if (!call->IsGuardedDevirtualizationCandidate())
+        {
+            inlineResult->NoteFatal(InlineObservation::CALLSITE_IS_NOT_DIRECT_MANAGED);
+            return;
+        }
+        else
+        {
+            assert(call->IsVirtualStub());
+        }
     }
 
     // The inliner gets confused when the unmanaged convention reverses arg order (like x86).
@@ -8924,11 +8933,6 @@ bool Compiler::impConsiderCallProbe(GenTreeCall* call, IL_OFFSET ilOffset)
 //
 Compiler::GDVProbeType Compiler::compClassifyGDVProbeType(GenTreeCall* call)
 {
-    if (call->gtCallType == CT_INDIRECT)
-    {
-        return GDVProbeType::None;
-    }
-
     if (!opts.jitFlags->IsSet(JitFlags::JIT_FLAG_BBINSTR) || IsAot())
     {
         return GDVProbeType::None;
diff --git a/src/coreclr/jit/inline.cpp b/src/coreclr/jit/inline.cpp
@@ -1344,9 +1344,7 @@ InlineContext* InlineStrategy::NewContext(InlineContext* parentContext, Statemen
     // which becomes a single statement where the IL location points to the
     // ldarg instruction.
     context->m_Location = stmt->GetDebugInfo().GetLocation();
-
-    assert(call->gtCallType == CT_USER_FUNC);
-    context->m_Callee = call->gtCallMethHnd;
+    context->m_Callee   = call->gtCallMethHnd;
 
 #if defined(DEBUG)
     context->m_Devirtualized = call->IsDevirtualized();
diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp
@@ -1773,7 +1773,7 @@ void CallArgs::AddFinalArgsAndDetermineABIInfo(Compiler* comp, GenTreeCall* call
             // add as a non-standard arg.
         }
     }
-    else if (call->gtCallType == CT_INDIRECT && (call->gtCallCookie != nullptr))
+    else if ((call->gtCallType == CT_INDIRECT) && !call->IsVirtualStub() && (call->gtCallCookie != nullptr))
     {
         assert(!call->IsUnmanaged());
 
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
@@ -8638,7 +8638,7 @@ bool CEEInfo::resolveVirtualMethodHelper(CORINFO_DEVIRTUALIZATION_INFO * info)
                 return false;
             }
         }
-        else if (!pObjMT->CanCastToInterface(pBaseMT))
+        else if (!pBaseMT->IsSharedByGenericInstantiations() && !pObjMT->CanCastToInterface(pBaseMT))
         {
             info->detail = CORINFO_DEVIRTUALIZATION_FAILED_CAST;
             return false;
@@ -8648,32 +8648,49 @@ bool CEEInfo::resolveVirtualMethodHelper(CORINFO_DEVIRTUALIZATION_INFO * info)
         // safely devirtualize.
         if (info->context != nullptr)
         {
-            // If the derived class is a shared class, make sure the
-            // owner class is too.
-            if (pObjMT->IsSharedByGenericInstantiations())
+            MethodTable* interfaceMT = nullptr;
+
+            if (pObjMT->IsSharedByGenericInstantiations() || pBaseMT->IsSharedByGenericInstantiations())
             {
                 MethodTable* pCanonBaseMT = pBaseMT->GetCanonicalMethodTable();
-
+                
                 // Check to see if the derived class implements multiple variants of a matching interface.
                 // If so, we cannot predict exactly which implementation is in use here.
                 MethodTable::InterfaceMapIterator it = pObjMT->IterateInterfaceMap();
                 int canonicallyMatchingInterfacesFound = 0;
+                MethodTable* interfaceMT = nullptr;
                 while (it.Next())
                 {
-                    if (it.GetInterface(pObjMT)->GetCanonicalMethodTable() == pCanonBaseMT)
+                    MethodTable* mt = it.GetInterface(pObjMT);
+                    if (mt->GetCanonicalMethodTable() == pCanonBaseMT)
                     {
+                        interfaceMT = mt;
                         canonicallyMatchingInterfacesFound++;
+
                         if (canonicallyMatchingInterfacesFound > 1)
                         {
-                            // Multiple canonically identical interfaces found when attempting to devirtualize an inexact interface dispatch
+                            // Multiple canonically identical interfaces found.
+                            //
                             info->detail = CORINFO_DEVIRTUALIZATION_MULTIPLE_IMPL;
                             return false;
                         }
                     }
                 }
-            }
+                
+                if (canonicallyMatchingInterfacesFound == 0)
+                {
+                    // The object doesn't implement the interface...
+                    //
+                    info->detail = CORINFO_DEVIRTUALIZATION_FAILED_CAST;
+                    return false;
+                }
 
-            pDevirtMD = pObjMT->GetMethodDescForInterfaceMethod(TypeHandle(pBaseMT), pBaseMD, FALSE /* throwOnConflict */);
+                pDevirtMD = pObjMT->GetMethodDescForInterfaceMethod(TypeHandle(interfaceMT), pBaseMD, FALSE /* throwOnConflict */);
+            }
+            else
+            {
+                pDevirtMD = pObjMT->GetMethodDescForInterfaceMethod(TypeHandle(pBaseMT), pBaseMD, FALSE /* throwOnConflict */);
+            }
         }
         else if (!pBaseMD->HasClassOrMethodInstantiation())
         {

Original file line number	Diff line number	Diff line change
`@@ -11886,7 +11886,7 @@ class GenTreeVisitor`
`11886`	`11886`
`11887`	`11887`	`if (call->gtCallType == CT_INDIRECT)`
`11888`	`11888`	`{`
`11889`		`- if (call->gtCallCookie != nullptr)`
	`11889`	`+ if (!call->IsVirtualStub() && (call->gtCallCookie != nullptr))`
`11890`	`11890`	`{`
`11891`	`11891`	`result = WalkTree(&call->gtCallCookie, call);`
`11892`	`11892`	`if (result == fgWalkResult::WALK_ABORT)`
Original file line number	Diff line number	Diff line change
`@@ -4683,7 +4683,8 @@ void GenTree::VisitOperands(TVisitor visitor)`
`4683`	`4683`
`4684`	`4684`	`if (call->gtCallType == CT_INDIRECT)`
`4685`	`4685`	`{`
`4686`		`- if ((call->gtCallCookie != nullptr) && (visitor(call->gtCallCookie) == VisitResult::Abort))`
	`4686`	`+ if (!call->IsVirtualStub() && (call->gtCallCookie != nullptr) &&`
	`4687`	`+ (visitor(call->gtCallCookie) == VisitResult::Abort))`
`4687`	`4688`	`{`
`4688`	`4689`	`return;`
`4689`	`4690`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5977,7 +5977,9 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)`
`5977`	`5977`	`if (call->gtCallType == CT_INDIRECT)`
`5978`	`5978`	`{`
`5979`	`5979`	`// pinvoke-calli cookie is a constant, or constant indirection`
`5980`		`- assert(call->gtCallCookie == nullptr \|\| call->gtCallCookie->OperIs(GT_CNS_INT, GT_IND));`
	`5980`	`+ // or a non-tree if this is a managed call.`
	`5981`	`+ assert(call->IsVirtualStub() \|\| (call->gtCallCookie == nullptr) \|\|`
	`5982`	`+ call->gtCallCookie->OperIs(GT_CNS_INT, GT_IND));`
`5981`	`5983`
`5982`	`5984`	`GenTree* indirect = call->gtCallAddr;`
`5983`	`5985`
`@@ -6725,7 +6727,7 @@ bool GenTree::TryGetUse(GenTree* operand, GenTree*** pUse)`
`6725`	`6727`	`}`
`6726`	`6728`	`if (call->gtCallType == CT_INDIRECT)`
`6727`	`6729`	`{`
`6728`		`- if (operand == call->gtCallCookie)`
	`6730`	`+ if (!call->IsVirtualStub() && (operand == call->gtCallCookie))`
`6729`	`6731`	`{`
`6730`	`6732`	`*pUse = &call->gtCallCookie;`
`6731`	`6733`	`return true;`
`@@ -9899,16 +9901,23 @@ GenTreeCall* Compiler::gtCloneExprCallHelper(GenTreeCall* tree)`
`9899`	`9901`	`/* Copy the union */`
`9900`	`9902`	`if (tree->gtCallType == CT_INDIRECT)`
`9901`	`9903`	`{`
`9902`		`- copy->gtCallCookie = tree->gtCallCookie ? gtCloneExpr(tree->gtCallCookie) : nullptr;`
`9903`		`- copy->gtCallAddr = tree->gtCallAddr ? gtCloneExpr(tree->gtCallAddr) : nullptr;`
	`9904`	`+ if (tree->IsVirtualStub())`
	`9905`	`+ {`
	`9906`	`+ copy->gtCallCookie = tree->gtCallCookie;`
	`9907`	`+ }`
	`9908`	`+ else`
	`9909`	`+ {`
	`9910`	`+ copy->gtCallCookie = tree->gtCallCookie ? gtCloneExpr(tree->gtCallCookie) : nullptr;`
	`9911`	`+ }`
	`9912`	`+ copy->gtCallAddr = tree->gtCallAddr ? gtCloneExpr(tree->gtCallAddr) : nullptr;`
`9904`	`9913`	`}`
`9905`	`9914`	`else`
`9906`	`9915`	`{`
`9907`	`9916`	`copy->gtCallMethHnd = tree->gtCallMethHnd;`
`9908`	`9917`	`copy->gtInlineCandidateInfo = tree->gtInlineCandidateInfo;`
`9909`		`- copy->gtInlineInfoCount = tree->gtInlineInfoCount;`
`9910`	`9918`	`}`
`9911`	`9919`
	`9920`	`+ copy->gtInlineInfoCount = tree->gtInlineInfoCount;`
`9912`	`9921`	`copy->gtLateDevirtualizationInfo = tree->gtLateDevirtualizationInfo;`
`9913`	`9922`
`9914`	`9923`	`copy->gtCallType = tree->gtCallType;`
`@@ -10641,7 +10650,7 @@ void GenTreeUseEdgeIterator::AdvanceCall()`
`10641`	`10650`	`assert(call->gtCallType == CT_INDIRECT);`
`10642`	`10651`
`10643`	`10652`	`m_advance = &GenTreeUseEdgeIterator::AdvanceCall<CALL_ADDRESS>;`
`10644`		`- if (call->gtCallCookie != nullptr)`
	`10653`	`+ if (!call->IsVirtualStub() && (call->gtCallCookie != nullptr))`
`10645`	`10654`	`{`
`10646`	`10655`	`m_edge = &call->gtCallCookie;`
`10647`	`10656`	`return;`
`@@ -10964,6 +10973,11 @@ void Compiler::gtDispNodeName(GenTree* tree)`
`10964`	`10973`	`}`
`10965`	`10974`	`else if (tree->AsCall()->gtCallType == CT_INDIRECT)`
`10966`	`10975`	`{`
	`10976`	`+ if (tree->AsCall()->IsVirtual())`
	`10977`	`+ {`
	`10978`	`+ callType = "CALLV";`
	`10979`	`+ }`
	`10980`	`+`
`10967`	`10981`	`ctType = " ind";`
`10968`	`10982`	`}`
`10969`	`10983`	`else`
Original file line number	Diff line number	Diff line change
`@@ -7276,7 +7276,8 @@ void Compiler::considerGuardedDevirtualization(GenTreeCall* call,`
`7276`	`7276`
`7277`	`7277`	`if (!canResolve)`
`7278`	`7278`	`{`
`7279`		`- JITDUMP("Can't figure out which method would be invoked, sorry\n");`
	`7279`	`+ JITDUMP("Can't figure out which method would be invoked, sorry. [%s]\n",`
	`7280`	`+ devirtualizationDetailToString(dvInfo.detail));`
`7280`	`7281`
`7281`	`7282`	`// Continue checking other candidates, maybe some of them will succeed.`
`7282`	`7283`	`break;`
`@@ -7695,20 +7696,28 @@ void Compiler::impMarkInlineCandidateHelper(GenTreeCall* call,`
`7695`	`7696`	`}`
`7696`	`7697`	`}`
`7697`	`7698`
`7698`		`- /* Ignore helper calls */`
`7699`		`-`
	`7699`	`+ // Ignore helper calls`
	`7700`	`+ //`
`7700`	`7701`	`if (call->IsHelperCall())`
`7701`	`7702`	`{`
`7702`	`7703`	`assert(!call->IsGuardedDevirtualizationCandidate());`
`7703`	`7704`	`inlineResult->NoteFatal(InlineObservation::CALLSITE_IS_CALL_TO_HELPER);`
`7704`	`7705`	`return;`
`7705`	`7706`	`}`
`7706`	`7707`
`7707`		`- /* Ignore indirect calls */`
	`7708`	`+ // Ignore indirect calls, unless they are indirect virtual stub calls with profile info.`
	`7709`	`+ //`
`7708`	`7710`	`if (call->gtCallType == CT_INDIRECT)`
`7709`	`7711`	`{`
`7710`		`- inlineResult->NoteFatal(InlineObservation::CALLSITE_IS_NOT_DIRECT_MANAGED);`
`7711`		`- return;`
	`7712`	`+ if (!call->IsGuardedDevirtualizationCandidate())`
	`7713`	`+ {`
	`7714`	`+ inlineResult->NoteFatal(InlineObservation::CALLSITE_IS_NOT_DIRECT_MANAGED);`
	`7715`	`+ return;`
	`7716`	`+ }`
	`7717`	`+ else`
	`7718`	`+ {`
	`7719`	`+ assert(call->IsVirtualStub());`
	`7720`	`+ }`
`7712`	`7721`	`}`
`7713`	`7722`
`7714`	`7723`	`// The inliner gets confused when the unmanaged convention reverses arg order (like x86).`
`@@ -8924,11 +8933,6 @@ bool Compiler::impConsiderCallProbe(GenTreeCall* call, IL_OFFSET ilOffset)`
`8924`	`8933`	`//`
`8925`	`8934`	`Compiler::GDVProbeType Compiler::compClassifyGDVProbeType(GenTreeCall* call)`
`8926`	`8935`	`{`
`8927`		`- if (call->gtCallType == CT_INDIRECT)`
`8928`		`- {`
`8929`		`- return GDVProbeType::None;`
`8930`		`- }`
`8931`		`-`
`8932`	`8936`	`if (!opts.jitFlags->IsSet(JitFlags::JIT_FLAG_BBINSTR) \|\| IsAot())`
`8933`	`8937`	`{`
`8934`	`8938`	`return GDVProbeType::None;`
Original file line number	Diff line number	Diff line change
`@@ -1773,7 +1773,7 @@ void CallArgs::AddFinalArgsAndDetermineABIInfo(Compiler* comp, GenTreeCall* call`
`1773`	`1773`	`// add as a non-standard arg.`
`1774`	`1774`	`}`
`1775`	`1775`	`}`
`1776`		`- else if (call->gtCallType == CT_INDIRECT && (call->gtCallCookie != nullptr))`
	`1776`	`+ else if ((call->gtCallType == CT_INDIRECT) && !call->IsVirtualStub() && (call->gtCallCookie != nullptr))`
`1777`	`1777`	`{`
`1778`	`1778`	`assert(!call->IsUnmanaged());`
`1779`	`1779`
Original file line number	Diff line number	Diff line change
`@@ -8638,7 +8638,7 @@ bool CEEInfo::resolveVirtualMethodHelper(CORINFO_DEVIRTUALIZATION_INFO * info)`
`8638`	`8638`	`return false;`
`8639`	`8639`	`}`
`8640`	`8640`	`}`
`8641`		`- else if (!pObjMT->CanCastToInterface(pBaseMT))`
	`8641`	`+ else if (!pBaseMT->IsSharedByGenericInstantiations() && !pObjMT->CanCastToInterface(pBaseMT))`
`8642`	`8642`	`{`
`8643`	`8643`	`info->detail = CORINFO_DEVIRTUALIZATION_FAILED_CAST;`
`8644`	`8644`	`return false;`
`@@ -8648,32 +8648,49 @@ bool CEEInfo::resolveVirtualMethodHelper(CORINFO_DEVIRTUALIZATION_INFO * info)`
`8648`	`8648`	`// safely devirtualize.`
`8649`	`8649`	`if (info->context != nullptr)`
`8650`	`8650`	`{`
`8651`		`- // If the derived class is a shared class, make sure the`
`8652`		`- // owner class is too.`
`8653`		`- if (pObjMT->IsSharedByGenericInstantiations())`
	`8651`	`+ MethodTable* interfaceMT = nullptr;`
	`8652`	`+`
	`8653`	`+ if (pObjMT->IsSharedByGenericInstantiations() \|\| pBaseMT->IsSharedByGenericInstantiations())`
`8654`	`8654`	`{`
`8655`	`8655`	`MethodTable* pCanonBaseMT = pBaseMT->GetCanonicalMethodTable();`
`8656`		`-`
	`8656`	`+`
`8657`	`8657`	`// Check to see if the derived class implements multiple variants of a matching interface.`
`8658`	`8658`	`// If so, we cannot predict exactly which implementation is in use here.`
`8659`	`8659`	`MethodTable::InterfaceMapIterator it = pObjMT->IterateInterfaceMap();`
`8660`	`8660`	`int canonicallyMatchingInterfacesFound = 0;`
	`8661`	`+ MethodTable* interfaceMT = nullptr;`
`8661`	`8662`	`while (it.Next())`
`8662`	`8663`	`{`
`8663`		`- if (it.GetInterface(pObjMT)->GetCanonicalMethodTable() == pCanonBaseMT)`
	`8664`	`+ MethodTable* mt = it.GetInterface(pObjMT);`
	`8665`	`+ if (mt->GetCanonicalMethodTable() == pCanonBaseMT)`
`8664`	`8666`	`{`
	`8667`	`+ interfaceMT = mt;`
`8665`	`8668`	`canonicallyMatchingInterfacesFound++;`
	`8669`	`+`
`8666`	`8670`	`if (canonicallyMatchingInterfacesFound > 1)`
`8667`	`8671`	`{`
`8668`		`- // Multiple canonically identical interfaces found when attempting to devirtualize an inexact interface dispatch`
	`8672`	`+ // Multiple canonically identical interfaces found.`
	`8673`	`+ //`
`8669`	`8674`	`info->detail = CORINFO_DEVIRTUALIZATION_MULTIPLE_IMPL;`
`8670`	`8675`	`return false;`
`8671`	`8676`	`}`
`8672`	`8677`	`}`
`8673`	`8678`	`}`
`8674`		`- }`
	`8679`	`+`
	`8680`	`+ if (canonicallyMatchingInterfacesFound == 0)`
	`8681`	`+ {`
	`8682`	`+ // The object doesn't implement the interface...`
	`8683`	`+ //`
	`8684`	`+ info->detail = CORINFO_DEVIRTUALIZATION_FAILED_CAST;`
	`8685`	`+ return false;`
	`8686`	`+ }`
`8675`	`8687`
`8676`		`- pDevirtMD = pObjMT->GetMethodDescForInterfaceMethod(TypeHandle(pBaseMT), pBaseMD, FALSE /* throwOnConflict */);`
	`8688`	`+ pDevirtMD = pObjMT->GetMethodDescForInterfaceMethod(TypeHandle(interfaceMT), pBaseMD, FALSE /* throwOnConflict */);`
	`8689`	`+ }`
	`8690`	`+ else`
	`8691`	`+ {`
	`8692`	`+ pDevirtMD = pObjMT->GetMethodDescForInterfaceMethod(TypeHandle(pBaseMT), pBaseMD, FALSE /* throwOnConflict */);`
	`8693`	`+ }`
`8677`	`8694`	`}`
`8678`	`8695`	`else if (!pBaseMD->HasClassOrMethodInstantiation())`
`8679`	`8696`	`{`