Fix Delegate dispatch.

src/coreclr/vm/comdelegate.cpp

@@ -1879,6 +1879,10 @@ Stub* COMDelegate::GetInvokeMethodStub(EEImplMethodDesc* pMD)
         if (*pMD->GetSig() != (IMAGE_CEE_CS_CALLCONV_HASTHIS | IMAGE_CEE_CS_CALLCONV_DEFAULT))
             COMPlusThrow(kInvalidProgramException);
 
+        PCCOR_SIGNATURE pSig;
+        DWORD cbSig;
+        pMD->GetSig(&pSig,&cbSig);
+
         MetaSig sig(pMD);
 
         BOOL fReturnVal = !sig.IsReturnTypeVoid();
@@ -1888,29 +1892,37 @@ Stub* COMDelegate::GetInvokeMethodStub(EEImplMethodDesc* pMD)
 
         ILCodeStream *pCode = sl.NewCodeStream(ILStubLinker::kDispatch);
 
-        // This stub is only used for rare indirect cases, for example
-        // when Delegate.Invoke method is wrapped into another delegate.
-        // Direct invocation of delegate is expanded by JIT.
-        // Emit a recursive call here to let JIT handle complex cases like
-        // virtual dispatch and GC safety.
-
         // Load the delegate object
         pCode->EmitLoadThis();
 
         // Load the arguments
         for (UINT paramCount = 0; paramCount < sig.NumFixedArgs(); paramCount++)
             pCode->EmitLDARG(paramCount);
 
-        // recursively call the delegate itself
+#ifdef FEATURE_INTERPRETER
+        // Call the underlying method pointer.
+        pCode->EmitLoadThis();
+        pCode->EmitLDFLD(FIELD__DELEGATE__METHOD_PTR);
+
+        mdToken sigTok = pCode->GetSigToken(pSig, cbSig);
+        pCode->EmitCALLI(sigTok, sig.NumFixedArgs(), fReturnVal);
+
+        pCode->EmitLoadThis();
+        pCode->EmitCALL(METHOD__GC__KEEP_ALIVE, 1, 0);
+#else
+        // This stub is only used for rare indirect cases, for example
+        // when Delegate.Invoke method is wrapped into another delegate.
+        // Direct invocation of delegate is expanded by JIT.
+        // Emit a recursive call here to let JIT handle complex cases like
+        // virtual dispatch and GC safety.
+
+        // Recursively call the delegate itself.
         pCode->EmitCALL(pCode->GetToken(pMD), sig.NumFixedArgs(), fReturnVal);
+#endif // !FEATURE_INTERPRETER
 
         // return
         pCode->EmitRET();
 
-        PCCOR_SIGNATURE pSig;
-        DWORD cbSig;
-        pMD->GetSig(&pSig,&cbSig);
-
         MethodDesc* pStubMD = ILStubCache::CreateAndLinkNewILStubMethodDesc(pMD->GetLoaderAllocator(),
                                                                 pMD->GetMethodTable(),
                                                                 ILSTUB_DELEGATE_INVOKE_METHOD,

src/coreclr/vm/interpreter.cpp

@@ -9289,6 +9289,11 @@ void Interpreter::DoCallWork(bool virtualCall, void* thisArg, CORINFO_RESOLVED_T
             didIntrinsic = true;
             break;
 
+        case NI_System_Runtime_CompilerServices_RuntimeHelpers_GetMethodTable:
+            DoGetMethodTable();
+            didIntrinsic = true;
+            break;
+
         case NI_System_Threading_Interlocked_CompareExchange:
             // Here and in other Interlocked.* intrinsics we use sigInfo.retType to be able
             // to detect small-integer overloads.
@@ -10986,6 +10991,34 @@ void Interpreter::DoIsReferenceOrContainsReferences(CORINFO_METHOD_HANDLE method
     m_curStackHt++;
 }
 
+void Interpreter::DoGetMethodTable()
+{
+    CONTRACTL{
+        THROWS;
+        GC_TRIGGERS;
+        MODE_COOPERATIVE;
+    } CONTRACTL_END;
+
+    _ASSERTE(m_curStackHt > 0);
+    unsigned ind = m_curStackHt - 1;
+
+#ifdef _DEBUG
+    _ASSERTE(OpStackTypeGet(ind).ToCorInfoType() == CORINFO_TYPE_CLASS);
+#endif // _DEBUG
+
+    Object* obj = OpStackGet<Object*>(ind);
+
+    if (obj == NULL)
+    {
+        ThrowNullPointerException();
+    }
+
+    MethodTable* pMT = obj->RawGetMethodTable();
+
+    OpStackSet<MethodTable*>(m_curStackHt, pMT);
+    OpStackTypeSet(m_curStackHt, InterpreterType(CORINFO_TYPE_NATIVEINT));
+}
+
 bool Interpreter::DoInterlockedCompareExchange(CorInfoType retType)
 {
     CONTRACTL{
@@ -11992,6 +12025,10 @@ Interpreter::InterpreterNamedIntrinsics Interpreter::getNamedIntrinsicID(CEEInfo
                         {
                             result = NI_System_Runtime_CompilerServices_RuntimeHelpers_IsReferenceOrContainsReferences;
                         }
+                        else if (strcmp(methodName, "GetMethodTable") == 0)
+                        {
+                            result = NI_System_Runtime_CompilerServices_RuntimeHelpers_GetMethodTable;
+                        }
                     }
                 }
             }

src/coreclr/vm/interpreter.h

@@ -923,6 +923,7 @@ class Interpreter
         NI_System_StubHelpers_GetStubContext,
         NI_System_Runtime_InteropService_MemoryMarshal_GetArrayDataReference,
         NI_System_Runtime_CompilerServices_RuntimeHelpers_IsReferenceOrContainsReferences,
+        NI_System_Runtime_CompilerServices_RuntimeHelpers_GetMethodTable,
         NI_System_Threading_Interlocked_CompareExchange,
         NI_System_Threading_Interlocked_Exchange,
         NI_System_Threading_Interlocked_ExchangeAdd,
@@ -1797,6 +1798,7 @@ class Interpreter
     void DoGetIsSupported();
     void DoGetArrayDataReference();
     void DoIsReferenceOrContainsReferences(CORINFO_METHOD_HANDLE method);
+    void DoGetMethodTable();
     bool DoInterlockedCompareExchange(CorInfoType retType);
     bool DoInterlockedExchange(CorInfoType retType);
     bool DoInterlockedExchangeAdd(CorInfoType retType);

src/coreclr/vm/stublink.cpp

@@ -1811,7 +1811,7 @@ bool StubLinker::EmitUnwindInfo(Stub* pStubRX, Stub* pStubRW, int globalsize, Lo
     //
 
     pHeaderRW->pNext = pStubHeapSegment->pUnwindHeaderList;
-    pStubHeapSegment->pUnwindHeaderList = pHeaderRW;
+    pStubHeapSegment->pUnwindHeaderList = pHeaderRX;
 
 #ifdef TARGET_AMD64
     // Publish Unwind info to ETW stack crawler
@@ -1826,7 +1826,7 @@ bool StubLinker::EmitUnwindInfo(Stub* pStubRX, Stub* pStubRW, int globalsize, Lo
 
 #ifdef _DEBUG
     _ASSERTE(pHeaderRW->IsRegistered());
-    _ASSERTE(   &pHeaderRW->FunctionEntry
+    _ASSERTE(   &pHeaderRX->FunctionEntry
              == FindStubFunctionEntry((ULONG64)pCode,                  EncodeDynamicFunctionTableContext(pStubHeapSegment, DYNFNTABLE_STUB)));
 #endif