Unify StubLinker stub memory management with JIT code allocator

src/coreclr/debug/daccess/request.cpp

@@ -2453,7 +2453,7 @@ ClrDataAccess::GetAppDomainData(CLRDATA_ADDRESS addr, struct DacpAppDomainData *
         PTR_LoaderAllocator pLoaderAllocator = SystemDomain::GetGlobalLoaderAllocator();
         appdomainData->pHighFrequencyHeap = HOST_CDADDR(pLoaderAllocator->GetHighFrequencyHeap());
         appdomainData->pLowFrequencyHeap = HOST_CDADDR(pLoaderAllocator->GetLowFrequencyHeap());
-        appdomainData->pStubHeap = HOST_CDADDR(pLoaderAllocator->GetStubHeap());
+        appdomainData->pStubHeap = HOST_CDADDR(pLoaderAllocator->GetExecutableHeap());
         appdomainData->appDomainStage = STAGE_OPEN;
 
         appdomainData->dwId = DefaultADID;
@@ -3681,7 +3681,7 @@ static const char *LoaderAllocatorLoaderHeapNames[] =
     "LowFrequencyHeap",
     "HighFrequencyHeap",
     "StaticsHeap",
-    "StubHeap",
+    "ExecutableStubHeap",
     "ExecutableHeap",
     "FixupPrecodeHeap",
     "NewStubPrecodeHeap",
@@ -3721,7 +3721,6 @@ HRESULT ClrDataAccess::GetLoaderAllocatorHeaps(CLRDATA_ADDRESS loaderAllocatorAd
             pLoaderHeaps[i++] = HOST_CDADDR(pLoaderAllocator->GetLowFrequencyHeap());
             pLoaderHeaps[i++] = HOST_CDADDR(pLoaderAllocator->GetHighFrequencyHeap());
             pLoaderHeaps[i++] = HOST_CDADDR(pLoaderAllocator->GetStaticsHeap());
-            pLoaderHeaps[i++] = HOST_CDADDR(pLoaderAllocator->GetStubHeap());
             pLoaderHeaps[i++] = HOST_CDADDR(pLoaderAllocator->GetExecutableHeap());
             pLoaderHeaps[i++] = HOST_CDADDR(pLoaderAllocator->GetFixupPrecodeHeap());
             pLoaderHeaps[i++] = HOST_CDADDR(pLoaderAllocator->GetNewStubPrecodeHeap());

src/coreclr/vm/appdomain.hpp

@@ -1297,7 +1297,6 @@ class AppDomain final
     }
 #endif // FEATURE_COMINTEROP
 
-    PTR_LoaderHeap GetStubHeap();
     PTR_LoaderHeap GetLowFrequencyHeap();
     PTR_LoaderHeap GetHighFrequencyHeap();
 

src/coreclr/vm/appdomain.inl

@@ -54,11 +54,4 @@ inline PTR_LoaderHeap AppDomain::GetLowFrequencyHeap()
     return GetLoaderAllocator()->GetLowFrequencyHeap();
 }
 
-inline PTR_LoaderHeap AppDomain::GetStubHeap()
-{
-    WRAPPER_NO_CONTRACT;
-    return GetLoaderAllocator()->GetStubHeap();
-}
-
 #endif  // _APPDOMAIN_I
-

src/coreclr/vm/assembly.cpp

@@ -557,13 +557,6 @@ PTR_LoaderHeap Assembly::GetHighFrequencyHeap()
 }
 
 
-PTR_LoaderHeap Assembly::GetStubHeap()
-{
-    WRAPPER_NO_CONTRACT;
-
-    return GetLoaderAllocator()->GetStubHeap();
-}
-
 Module *Assembly::FindModuleByExportedType(mdExportedType mdType,
                                            Loader::LoadFlag loadFlag,
                                            mdTypeDef mdNested,

src/coreclr/vm/assembly.hpp

@@ -249,8 +249,6 @@ class Assembly
 
     PTR_LoaderHeap GetLowFrequencyHeap();
     PTR_LoaderHeap GetHighFrequencyHeap();
-    PTR_LoaderHeap GetStubHeap();
-
     PTR_Module GetModule()
     {
         LIMITED_METHOD_CONTRACT;

src/coreclr/vm/class.h

@@ -1922,7 +1922,7 @@ class DelegateEEClass : public EEClass
     }
 
     // We need a LoaderHeap that lives at least as long as the DelegateEEClass, but ideally no longer
-    LoaderHeap *GetStubHeap();
+    LoaderAllocator *GetStubHeap();
 #endif // !DACCESS_COMPILE
 
 };

src/coreclr/vm/codeman.h

@@ -102,6 +102,8 @@ enum StubCodeBlockKind : int
     STUB_CODE_BLOCK_DYNAMICHELPER = 3,
     STUB_CODE_BLOCK_STUBPRECODE = 4,
     STUB_CODE_BLOCK_FIXUPPRECODE = 5,
+    STUB_CODE_BLOCK_STUBLINK = 0xB,
+    STUB_CODE_BLOCK_SHUFFLE_THUNK = 0xC,
 #ifdef FEATURE_VIRTUAL_STUB_DISPATCH
     STUB_CODE_BLOCK_VSD_DISPATCH_STUB = 6,
     STUB_CODE_BLOCK_VSD_RESOLVE_STUB = 7,
@@ -129,6 +131,10 @@ inline const char *GetStubCodeBlockKindString(StubCodeBlockKind kind)
     case STUB_CODE_BLOCK_CALLCOUNTING:
         return "CallCountingStub";
 #endif
+    case STUB_CODE_BLOCK_STUBLINK:
+        return "StubLink";
+    case STUB_CODE_BLOCK_SHUFFLE_THUNK:
+        return "ShuffleThunk";
     case STUB_CODE_BLOCK_DYNAMICHELPER:
         return "MethodCallThunk";
     case STUB_CODE_BLOCK_FIXUPPRECODE:

src/coreclr/vm/comdelegate.cpp

@@ -783,7 +783,7 @@ void COMDelegate::Init()
     }
     CONTRACTL_END;
 #if defined(FEATURE_PORTABLE_SHUFFLE_THUNKS) || defined(TARGET_X86)
-    s_pShuffleThunkCache = new ShuffleThunkCache(SystemDomain::GetGlobalLoaderAllocator()->GetStubHeap());
+    s_pShuffleThunkCache = new ShuffleThunkCache(SystemDomain::GetGlobalLoaderAllocator());
 #endif
 }
 
@@ -821,9 +821,9 @@ CLRToCOMCallInfo * COMDelegate::PopulateCLRToCOMCallInfo(MethodTable * pDelMT)
 #endif // FEATURE_COMINTEROP
 
 // We need a LoaderHeap that lives at least as long as the DelegateEEClass, but ideally no longer
-LoaderHeap *DelegateEEClass::GetStubHeap()
+LoaderAllocator *DelegateEEClass::GetStubHeap()
 {
-    return GetInvokeMethod()->GetLoaderAllocator()->GetStubHeap();
+    return GetInvokeMethod()->GetLoaderAllocator();
 }
 
 static Stub* CreateILDelegateShuffleThunk(MethodDesc* pDelegateMD, bool callTargetWithThis)

src/coreclr/vm/comdelegate.h

@@ -175,7 +175,7 @@ struct ShuffleEntry
 class ShuffleThunkCache : public StubCacheBase
 {
 public:
-    ShuffleThunkCache(LoaderHeap* heap) : StubCacheBase(heap)
+    ShuffleThunkCache(LoaderAllocator* pLoaderAllocator) : StubCacheBase(pLoaderAllocator)
     {
     }
 private:

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -403,7 +403,6 @@ CDAC_TYPE_FIELD(LoaderAllocator, T_UINT32, ReferenceCount, cdac_data<LoaderAlloc
 CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, HighFrequencyHeap, cdac_data<LoaderAllocator>::HighFrequencyHeap)
 CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, LowFrequencyHeap, cdac_data<LoaderAllocator>::LowFrequencyHeap)
 CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, StaticsHeap, cdac_data<LoaderAllocator>::StaticsHeap)
-CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, StubHeap, cdac_data<LoaderAllocator>::StubHeap)
 CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, ExecutableHeap, cdac_data<LoaderAllocator>::ExecutableHeap)
 #ifdef HAS_FIXUP_PRECODE
 CDAC_TYPE_FIELD(LoaderAllocator, T_POINTER, FixupPrecodeHeap, cdac_data<LoaderAllocator>::FixupPrecodeHeap)

src/coreclr/vm/loaderallocator.cpp

@@ -23,8 +23,6 @@
 
 //#define ENABLE_LOG_LOADER_ALLOCATOR_CLEANUP 1
 
-#define STUBMANAGER_RANGELIST(stubManager) (stubManager::g_pManager->GetRangeList())
-
 UINT64 LoaderAllocator::cLoaderAllocatorsCreated = 1;
 
 LoaderAllocator::LoaderAllocator(bool collectible) :
@@ -40,7 +38,6 @@ LoaderAllocator::LoaderAllocator(bool collectible) :
     m_InitialReservedMemForLoaderHeaps = NULL;
     m_pLowFrequencyHeap = NULL;
     m_pHighFrequencyHeap = NULL;
-    m_pStubHeap = NULL;
     m_pExecutableHeap = NULL;
 #ifdef FEATURE_READYTORUN
 #ifndef FEATURE_STUBPRECODE_DYNAMIC_HELPERS
@@ -1122,7 +1119,6 @@ void LoaderAllocator::Init(BYTE *pExecutableHeapMemory)
     DWORD dwLowFrequencyHeapReserveSize;
     DWORD dwHighFrequencyHeapReserveSize;
     DWORD dwStaticsHeapReserveSize;
-    DWORD dwStubHeapReserveSize;
     DWORD dwExecutableHeapReserveSize;
     DWORD dwCodeHeapReserveSize;
     DWORD dwVSDHeapReserveSize;
@@ -1133,7 +1129,6 @@ void LoaderAllocator::Init(BYTE *pExecutableHeapMemory)
     {
         dwLowFrequencyHeapReserveSize  = COLLECTIBLE_LOW_FREQUENCY_HEAP_SIZE;
         dwHighFrequencyHeapReserveSize = COLLECTIBLE_HIGH_FREQUENCY_HEAP_SIZE;
-        dwStubHeapReserveSize          = COLLECTIBLE_STUB_HEAP_SIZE;
         dwCodeHeapReserveSize          = COLLECTIBLE_CODEHEAP_SIZE;
         dwVSDHeapReserveSize           = COLLECTIBLE_VIRTUALSTUBDISPATCH_HEAP_SPACE;
         dwStaticsHeapReserveSize       = 0;
@@ -1142,7 +1137,6 @@ void LoaderAllocator::Init(BYTE *pExecutableHeapMemory)
     {
         dwLowFrequencyHeapReserveSize  = LOW_FREQUENCY_HEAP_RESERVE_SIZE;
         dwHighFrequencyHeapReserveSize = HIGH_FREQUENCY_HEAP_RESERVE_SIZE;
-        dwStubHeapReserveSize          = STUB_HEAP_RESERVE_SIZE;
         dwStaticsHeapReserveSize       = STATIC_FIELD_HEAP_RESERVE_SIZE;
 
         // Non-collectible assemblies do not reserve space for these heaps.
@@ -1163,7 +1157,6 @@ void LoaderAllocator::Init(BYTE *pExecutableHeapMemory)
     DWORD dwTotalReserveMemSize = dwLowFrequencyHeapReserveSize
                                 + dwHighFrequencyHeapReserveSize
                                 + dwStaticsHeapReserveSize
-                                + dwStubHeapReserveSize
                                 + dwCodeHeapReserveSize
                                 + dwVSDHeapReserveSize
                                 + dwExecutableHeapReserveSize;
@@ -1238,15 +1231,6 @@ void LoaderAllocator::Init(BYTE *pExecutableHeapMemory)
         m_pStaticsHeap = m_pHighFrequencyHeap;
     }
 
-    m_pStubHeap = new (&m_StubHeapInstance) LoaderHeap(STUB_HEAP_RESERVE_SIZE,
-                                                       STUB_HEAP_COMMIT_SIZE,
-                                                       initReservedMem,
-                                                       dwStubHeapReserveSize,
-                                                       STUBMANAGER_RANGELIST(StubLinkStubManager),
-                                                       LoaderHeapImplementationKind::Executable);
-
-    initReservedMem += dwStubHeapReserveSize;
-
 #ifndef FEATURE_PORTABLE_ENTRYPOINTS
     m_pNewStubPrecodeHeap = new (&m_NewStubPrecodeHeapInstance) InterleavedLoaderHeap(
                                                                            &m_stubPrecodeRangeList,
@@ -1452,12 +1436,6 @@ void LoaderAllocator::Terminate()
         m_pHighFrequencyHeap = NULL;
     }
 
-    if (m_pStubHeap != NULL)
-    {
-        m_pStubHeap->~LoaderHeap();
-        m_pStubHeap = NULL;
-    }
-
 #ifdef HAS_FIXUP_PRECODE
     if (m_pFixupPrecodeHeap != NULL)
     {
@@ -1544,10 +1522,6 @@ void LoaderAllocator::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
     {
         m_pStaticsHeap->EnumMemoryRegions(flags);
     }
-    if (m_pStubHeap.IsValid())
-    {
-        m_pStubHeap->EnumMemoryRegions(flags);
-    }
     if (m_pExecutableHeap.IsValid())
     {
         m_pExecutableHeap->EnumMemoryRegions(flags);
@@ -1590,8 +1564,6 @@ SIZE_T LoaderAllocator::EstimateSize()
         retval+=m_pStaticsHeap->GetSize();
     if(m_pLowFrequencyHeap)
         retval+=m_pLowFrequencyHeap->GetSize();
-    if(m_pStubHeap)
-        retval+=m_pStubHeap->GetSize();
     if(m_pStringLiteralMap)
         retval+=m_pStringLiteralMap->GetSize();
     if(m_pVirtualCallStubManager)
@@ -1791,11 +1763,11 @@ void AssemblyLoaderAllocator::Init()
 #ifndef FEATURE_PORTABLE_ENTRYPOINTS
     if (IsCollectible())
     {
-        // TODO: the ShuffleThunkCache should really be using the m_pStubHeap, however the unloadability support
+        // TODO: the ShuffleThunkCache should really be using collectible stub-linked executable memory, however the unloadability support
         // doesn't track the stubs or the related delegate classes and so we get crashes when a stub is used after
         // the AssemblyLoaderAllocator is gone (the stub memory is unmapped).
         // https://github.com/dotnet/runtime/issues/55697 tracks this issue.
-        m_pShuffleThunkCache = new ShuffleThunkCache(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap());
+        m_pShuffleThunkCache = new ShuffleThunkCache(SystemDomain::GetGlobalLoaderAllocator());
     }
 #endif // !FEATURE_PORTABLE_ENTRYPOINTS
 }

src/coreclr/vm/loaderallocator.hpp

@@ -320,7 +320,6 @@ class LoaderAllocator
     BYTE *              m_InitialReservedMemForLoaderHeaps;
     BYTE                m_LowFreqHeapInstance[sizeof(LoaderHeap)];
     BYTE                m_HighFreqHeapInstance[sizeof(LoaderHeap)];
-    BYTE                m_StubHeapInstance[sizeof(LoaderHeap)];
 #ifdef HAS_FIXUP_PRECODE
     BYTE                m_FixupPrecodeHeapInstance[sizeof(InterleavedLoaderHeap)];
 #endif // HAS_FIXUP_PRECODE
@@ -336,7 +335,6 @@ class LoaderAllocator
     PTR_LoaderHeap      m_pLowFrequencyHeap;
     PTR_LoaderHeap      m_pHighFrequencyHeap;
     PTR_LoaderHeap      m_pStaticsHeap;
-    PTR_LoaderHeap      m_pStubHeap; // stubs for PInvoke, remoting, etc
     PTR_LoaderHeap      m_pExecutableHeap;
 #ifdef FEATURE_READYTORUN
 #ifdef FEATURE_STUBPRECODE_DYNAMIC_HELPERS
@@ -657,12 +655,6 @@ class LoaderAllocator
         return m_pStaticsHeap;
     }
 
-    PTR_LoaderHeap GetStubHeap()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pStubHeap;
-    }
-
 #ifndef FEATURE_PORTABLE_ENTRYPOINTS
     PTR_InterleavedLoaderHeap GetNewStubPrecodeHeap()
     {
@@ -950,7 +942,6 @@ struct cdac_data<LoaderAllocator>
     static constexpr size_t HighFrequencyHeap = offsetof(LoaderAllocator, m_pHighFrequencyHeap);
     static constexpr size_t LowFrequencyHeap = offsetof(LoaderAllocator, m_pLowFrequencyHeap);
     static constexpr size_t StaticsHeap = offsetof(LoaderAllocator, m_pStaticsHeap);
-    static constexpr size_t StubHeap = offsetof(LoaderAllocator, m_pStubHeap);
     static constexpr size_t ExecutableHeap = offsetof(LoaderAllocator, m_pExecutableHeap);
 #ifdef HAS_FIXUP_PRECODE
     static constexpr size_t FixupPrecodeHeap = offsetof(LoaderAllocator, m_pFixupPrecodeHeap);
@@ -1115,4 +1106,3 @@ class LOADERHANDLEHolder
 #include "loaderallocator.inl"
 
 #endif //  __LoaderAllocator_h__
-

src/coreclr/vm/prestub.cpp

@@ -1743,13 +1743,13 @@ Stub * MakeUnboxingStubWorker(MethodDesc *pMD)
 
         sl.EmitComputedInstantiatingMethodStub(pUnboxedMD, &portableShuffle[0], NULL);
 
-        return sl.Link(pMD->GetLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_INSTANTIATING_METHOD, "UnboxingStub");
+        return sl.Link(pMD->GetLoaderAllocator(), NEWSTUB_FL_INSTANTIATING_METHOD, "UnboxingStub");
     }
 #elif defined(TARGET_X86)
     CPUSTUBLINKER sl;
     if (sl.EmitUnboxMethodStub(pUnboxedMD))
     {
-        return sl.Link(pMD->GetLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_NONE, "UnboxingStub");
+        return sl.Link(pMD->GetLoaderAllocator(), NEWSTUB_FL_NONE, "UnboxingStub");
     }
 #endif // FEATURE_PORTABLE_SHUFFLE_THUNKS || TARGET_X86
 
@@ -1798,13 +1798,13 @@ Stub * MakeInstantiatingStubWorker(MethodDesc *pMD)
         _ASSERTE(pSharedMD != NULL && pSharedMD != pMD);
         sl.EmitComputedInstantiatingMethodStub(pSharedMD, &portableShuffle[0], extraArg);
 
-        return sl.Link(pMD->GetLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_INSTANTIATING_METHOD, "InstantiatingStub");
+        return sl.Link(pMD->GetLoaderAllocator(), NEWSTUB_FL_INSTANTIATING_METHOD, "InstantiatingStub");
     }
 #elif defined(TARGET_X86)
     CPUSTUBLINKER sl;
     if (sl.EmitInstantiatingMethodStub(pSharedMD, extraArg))
     {
-        return sl.Link(pMD->GetLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_NONE, "InstantiatingStub");
+        return sl.Link(pMD->GetLoaderAllocator(), NEWSTUB_FL_NONE, "InstantiatingStub");
     }
 #endif // FEATURE_PORTABLE_SHUFFLE_THUNKS || TARGET_X86
 

src/coreclr/vm/stubcache.cpp

@@ -18,7 +18,7 @@
 //---------------------------------------------------------
 // Constructor
 //---------------------------------------------------------
-StubCacheBase::StubCacheBase(LoaderHeap *pHeap) :
+StubCacheBase::StubCacheBase(LoaderAllocator *pLoaderAllocator) :
     CClosedHashBase(
 #ifdef _DEBUG
                       3,
@@ -30,15 +30,9 @@ StubCacheBase::StubCacheBase(LoaderHeap *pHeap) :
                       FALSE
                    ),
     m_crst(CrstStubCache),
-    m_heap(pHeap)
+    m_pLoaderAllocator(pLoaderAllocator)
 {
     WRAPPER_NO_CONTRACT;
-
-#ifdef TARGET_UNIX
-    if (m_heap == NULL)
-        m_heap = SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap();
-#endif
-
 }
 
 
@@ -112,7 +106,7 @@ Stub *StubCacheBase::Canonicalize(const BYTE * pRawStub, const char *stubType)
     // and link up the stub.
     CodeLabel *plabel = psl->EmitNewCodeLabel();
     psl->EmitBytes(pRawStub, Length(pRawStub));
-    pstub = psl->Link(m_heap, linkFlags, stubType);
+    pstub = psl->Link(m_pLoaderAllocator, linkFlags, stubType);
     UINT32 offset = psl->GetLabelOffset(plabel);
 
     if (offset > 0xffff)

src/coreclr/vm/stubcache.h

@@ -44,7 +44,7 @@ class StubCacheBase : private CClosedHashBase
     //---------------------------------------------------------
     // Constructor
     //---------------------------------------------------------
-    StubCacheBase(LoaderHeap *heap = 0);
+    StubCacheBase(LoaderAllocator *pLoaderAllocator = NULL);
 
     //---------------------------------------------------------
     // Destructor
@@ -127,7 +127,7 @@ class StubCacheBase : private CClosedHashBase
 
 private:
     Crst        m_crst;
-    LoaderHeap* m_heap;
+    LoaderAllocator* m_pLoaderAllocator;
 };