Remove DelegateInvokeStubManager

src/coreclr/inc/dacvars.h

@@ -94,7 +94,6 @@ DEFINE_DACVAR(PTR_StubLinkStubManager, StubLinkStubManager__g_pManager, StubLink
 DEFINE_DACVAR(PTR_ThunkHeapStubManager, ThunkHeapStubManager__g_pManager, ThunkHeapStubManager::g_pManager)
 DEFINE_DACVAR(PTR_JumpStubStubManager, JumpStubStubManager__g_pManager, JumpStubStubManager::g_pManager)
 DEFINE_DACVAR(PTR_RangeSectionStubManager, RangeSectionStubManager__g_pManager, RangeSectionStubManager::g_pManager)
-DEFINE_DACVAR(PTR_DelegateInvokeStubManager, DelegateInvokeStubManager__g_pManager, DelegateInvokeStubManager::g_pManager)
 DEFINE_DACVAR(PTR_VirtualCallStubManagerManager, VirtualCallStubManagerManager__g_pManager, VirtualCallStubManagerManager::g_pManager)
 DEFINE_DACVAR(PTR_CallCountingStubManager, CallCountingStubManager__g_pManager, CallCountingStubManager::g_pManager)
 

src/coreclr/inc/vptr_list.h

@@ -34,7 +34,6 @@ VPTR_CLASS(JumpStubStubManager)
 VPTR_CLASS(RangeSectionStubManager)
 VPTR_CLASS(ILStubManager)
 VPTR_CLASS(InteropDispatchStubManager)
-VPTR_CLASS(DelegateInvokeStubManager)
 #if defined(TARGET_X86) && !defined(UNIX_X86_ABI)
 VPTR_CLASS(TailCallStubManager)
 #endif

src/coreclr/vm/appdomain.cpp

@@ -956,7 +956,6 @@ void SystemDomain::Attach()
 
     // Initialize stub managers
     PrecodeStubManager::Init();
-    DelegateInvokeStubManager::Init();
     JumpStubStubManager::Init();
     RangeSectionStubManager::Init();
     ILStubManager::Init();

src/coreclr/vm/array.cpp

@@ -1124,7 +1124,7 @@ void GenerateArrayOpScript(ArrayMethodDesc *pMD, ArrayOpScript *paos)
 //---------------------------------------------------------
 class ArrayStubCache : public StubCacheBase
 {
-    virtual void CompileStub(const BYTE *pRawStub,
+    virtual DWORD CompileStub(const BYTE *pRawStub,
                              StubLinker *psl);
     virtual UINT Length(const BYTE *pRawStub);
 
@@ -1169,12 +1169,13 @@ Stub *GenerateArrayOpStub(ArrayMethodDesc* pMD)
     return pArrayOpStub;
 }
 
-void ArrayStubCache::CompileStub(const BYTE *pRawStub,
+DWORD ArrayStubCache::CompileStub(const BYTE *pRawStub,
                                  StubLinker *psl)
 {
     STANDARD_VM_CONTRACT;
 
     ((CPUSTUBLINKER*)psl)->EmitArrayOpStub((ArrayOpScript*)pRawStub);
+    return NEWSTUB_FL_NONE;
 }
 
 UINT ArrayStubCache::Length(const BYTE *pRawStub)

src/coreclr/vm/class.cpp

@@ -146,12 +146,16 @@ void EEClass::Destruct(MethodTable * pOwningMT)
 
         if (pDelegateEEClass->m_pStaticCallStub)
         {
+            // Collect data to remove stub entry from StubManager if
+            // stub is deleted.
+            BYTE* entry = (BYTE*)pDelegateEEClass->m_pStaticCallStub->GetEntryPoint();
+            UINT length = pDelegateEEClass->m_pStaticCallStub->GetNumCodeBytes();
+
             ExecutableWriterHolder<Stub> stubWriterHolder(pDelegateEEClass->m_pStaticCallStub, sizeof(Stub));
             BOOL fStubDeleted = stubWriterHolder.GetRW()->DecRef();
-
             if (fStubDeleted)
             {
-                DelegateInvokeStubManager::g_pManager->RemoveStub(pDelegateEEClass->m_pStaticCallStub);
+                StubLinkStubManager::g_pManager->RemoveStubRange(entry, length);
             }
         }
         if (pDelegateEEClass->m_pInstRetBuffCallStub)

src/coreclr/vm/comdelegate.h

@@ -37,7 +37,6 @@ class COMDelegate
     // friend VOID CPUSTUBLINKER::EmitMulticastInvoke(...);
     // friend VOID CPUSTUBLINKER::EmitShuffleThunk(...);
     friend class CPUSTUBLINKER;
-    friend class DelegateInvokeStubManager;
     friend BOOL MulticastFrame::TraceFrame(Thread *thread, BOOL fromPatch,
                                 TraceDestination *trace, REGDISPLAY *regs);
 
@@ -213,12 +212,13 @@ class ShuffleThunkCache : public StubCacheBase
     // Compile a static delegate shufflethunk. Always returns
     // STANDALONE since we don't interpret these things.
     //---------------------------------------------------------
-    virtual void CompileStub(const BYTE *pRawStub,
+    virtual DWORD CompileStub(const BYTE *pRawStub,
                              StubLinker *pstublinker)
     {
         STANDARD_VM_CONTRACT;
 
         ((CPUSTUBLINKER*)pstublinker)->EmitShuffleThunk((ShuffleEntry*)pRawStub);
+        return NEWSTUB_FL_THUNK;
     }
 
     //---------------------------------------------------------
@@ -234,19 +234,6 @@ class ShuffleThunkCache : public StubCacheBase
         }
         return sizeof(ShuffleEntry) * (UINT)(1 + (pse - (ShuffleEntry*)pRawStub));
     }
-
-    virtual void AddStub(const BYTE* pRawStub, Stub* pNewStub)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_NOTRIGGER;
-            MODE_ANY;
-        }
-        CONTRACTL_END;
-
-        DelegateInvokeStubManager::g_pManager->AddStub(pNewStub);
-    }
 };
 
 #endif  // _COMDELEGATE_H_

src/coreclr/vm/frames.cpp

@@ -1925,7 +1925,7 @@ BOOL MulticastFrame::TraceFrame(Thread *thread, BOOL fromPatch,
                            ((ArrayBase *)pbDelInvocationList)->GetComponentSize()*delegateCount);
 
         _ASSERTE(pbDel);
-        return DelegateInvokeStubManager::TraceDelegateObject(pbDel, trace);
+        return StubLinkStubManager::TraceDelegateObject(pbDel, trace);
     }
 #endif // !DACCESS_COMPILE
 }

src/coreclr/vm/stubcache.cpp

@@ -108,14 +108,14 @@ Stub *StubCacheBase::Canonicalize(const BYTE * pRawStub)
     // Couldn't find it, let's try to compile it.
     CPUSTUBLINKER sl;
     CPUSTUBLINKER *psl = &sl;
-    CompileStub(pRawStub, psl);
+    DWORD linkFlags = CompileStub(pRawStub, psl);
 
     // Append the raw stub to the native stub
     // and link up the stub.
     CodeLabel *plabel = psl->EmitNewCodeLabel();
     psl->EmitBytes(pRawStub, Length(pRawStub));
     StubHolder<Stub> pstub;
-    pstub = psl->Link(m_heap);
+    pstub = psl->Link(m_heap, linkFlags);
     UINT32 offset = psl->GetLabelOffset(plabel);
 
     if (offset > 0xffff)

src/coreclr/vm/stubcache.h

@@ -67,13 +67,9 @@ class StubCacheBase : private CClosedHashBase
     // This method should compile into the provided stublinker (but
     // not call the Link method.)
     //
-    // It should return the chosen compilation mode.
-    //
-    // If the method fails for some reason, it should return
-    // INTERPRETED so that the EE can fall back on the already
-    // created ML code.
+    // It can return flags that will be passed to StubLinker::Link().
     //---------------------------------------------------------
-    virtual void CompileStub(const BYTE *pRawStub,
+    virtual DWORD CompileStub(const BYTE *pRawStub,
                              StubLinker *psl) = 0;
 
     //---------------------------------------------------------

src/coreclr/vm/stublink.cpp

@@ -2231,6 +2231,8 @@ void Stub::SetupStub(int numCodeBytes, DWORD flags
             m_numCodeBytesAndFlags |= EXTERNAL_ENTRY_BIT;
         if ((flags & NEWSTUB_FL_INSTANTIATING_METHOD) != 0)
             m_numCodeBytesAndFlags |= INSTANTIATING_STUB_BIT;
+        if ((flags & NEWSTUB_FL_THUNK) != 0)
+            m_numCodeBytesAndFlags |= THUNK_BIT;
     }
 
 #ifdef STUBLINKER_GENERATES_UNWIND_INFO

src/coreclr/vm/stublink.h

@@ -439,7 +439,8 @@ enum NewStubFlags
     NEWSTUB_FL_INSTANTIATING_METHOD = 0x00000001,
     NEWSTUB_FL_MULTICAST            = 0x00000002,
     NEWSTUB_FL_EXTERNAL             = 0x00000004,
-    NEWSTUB_FL_LOADERHEAP           = 0x00000008
+    NEWSTUB_FL_LOADERHEAP           = 0x00000008,
+    NEWSTUB_FL_THUNK                = 0x00000010
 };
 
 
@@ -464,6 +465,7 @@ class Stub
         LOADER_HEAP_BIT         = 0x20000000,
         INSTANTIATING_STUB_BIT  = 0x10000000,
         UNWIND_INFO_BIT         = 0x08000000,
+        THUNK_BIT               = 0x04000000,
 
         CODEBYTES_MASK          = UNWIND_INFO_BIT - 1,
         MAX_CODEBYTES           = CODEBYTES_MASK + 1,
@@ -513,6 +515,15 @@ class Stub
             return (m_numCodeBytesAndFlags & INSTANTIATING_STUB_BIT) != 0;
         }
 
+        //-------------------------------------------------------------------
+        // Used by the debugger to help step through stubs
+        //-------------------------------------------------------------------
+        BOOL IsManagedThunk()
+        {
+            LIMITED_METHOD_CONTRACT;
+            return (m_numCodeBytesAndFlags & THUNK_BIT) != 0;
+        }
+
         //-------------------------------------------------------------------
         // For stubs which execute user code, a patch offset needs to be set
         // to tell the debugger how far into the stub code the debugger has