Unify StubLinker stub memory management with JIT code allocator

docs/design/datacontracts/ExecutionManager.md

@@ -144,7 +144,9 @@ public enum CodeKind : uint
     Jitted = 11,
     ReadyToRun = 12,
     Interpreter = 13,
-    ThePreStub = 14
+    ThePreStub = 14,
+    WrapperStub = 15,
+    ShuffleThunk = 16
 }
 ```
 

docs/design/datacontracts/Loader.md

@@ -63,7 +63,6 @@ enum LoaderAllocatorHeapType
     LowFrequencyHeap,
     HighFrequencyHeap,
     StaticsHeap,
-    StubHeap,
     ExecutableHeap,
     FixupPrecodeHeap,
     NewStubPrecodeHeap,
@@ -112,7 +111,6 @@ TargetPointer GetGlobalLoaderAllocator();
 TargetPointer GetSystemAssembly();
 TargetPointer GetHighFrequencyHeap(TargetPointer loaderAllocatorPointer);
 TargetPointer GetLowFrequencyHeap(TargetPointer loaderAllocatorPointer);
-TargetPointer GetStubHeap(TargetPointer loaderAllocatorPointer);
 TargetPointer GetObjectHandle(TargetPointer loaderAllocatorPointer);
 TargetPointer GetILHeader(ModuleHandle handle, uint token);
 TargetPointer GetDynamicIL(ModuleHandle handle, uint token);
@@ -193,7 +191,6 @@ enum ClrModifiableAssemblies : uint
 | `LoaderAllocator` | `ObjectHandle` | `ObjectHandle` | Handle to the managed loader allocator object |
 | `LoaderAllocator` | `ReferenceCount` | `uint32` | Reference count of the loader allocator |
 | `LoaderAllocator` | `StaticsHeap` | `pointer` | Heap containing statics-related allocations |
-| `LoaderAllocator` | `StubHeap` | `pointer` | Heap containing runtime stubs |
 | `LoaderAllocator` | `VirtualCallStubManager` | `pointer` | Pointer to the virtual-call stub manager |
 | `LoaderHeap` | `FirstBlock` | `pointer` | Pointer to the first loader-heap block |
 | `LoaderHeapBlock` | `Next` | `pointer` | Pointer to the next loader-heap block |
@@ -850,11 +847,6 @@ TargetPointer GetLowFrequencyHeap(TargetPointer loaderAllocatorPointer)
     return target.ReadPointer(loaderAllocatorPointer + /* LoaderAllocator::LowFrequencyHeap offset */);
 }
 
-TargetPointer GetStubHeap(TargetPointer loaderAllocatorPointer)
-{
-    return target.ReadPointer(loaderAllocatorPointer + /* LoaderAllocator::StubHeap offset */);
-}
-
 TargetPointer GetObjectHandle(TargetPointer loaderAllocatorPointer)
 {
     return target.ReadPointer(loaderAllocatorPointer + /* LoaderAllocator::ObjectHandle offset */);
@@ -870,7 +862,6 @@ IReadOnlyDictionary<LoaderAllocatorHeapType, TargetPointer> GetLoaderAllocatorHe
         [LoaderAllocatorHeapType.LowFrequencyHeap] = la.LowFrequencyHeap,
         [LoaderAllocatorHeapType.HighFrequencyHeap] = la.HighFrequencyHeap,
         [LoaderAllocatorHeapType.StaticsHeap] = la.StaticsHeap,
-        [LoaderAllocatorHeapType.StubHeap] = la.StubHeap,
         [LoaderAllocatorHeapType.ExecutableHeap] = la.ExecutableHeap,
     };
 

docs/design/datacontracts/RuntimeTypeSystem.md

@@ -585,7 +585,6 @@ static class RuntimeTypeSystem_1_Helpers
 | `LoaderAllocator` | `ObjectHandle` | `ObjectHandle` | Handle to the managed loader allocator object |
 | `LoaderAllocator` | `ReferenceCount` | `uint32` | Reference count of the loader allocator |
 | `LoaderAllocator` | `StaticsHeap` | `pointer` | Heap containing statics-related allocations |
-| `LoaderAllocator` | `StubHeap` | `pointer` | Heap containing runtime stubs |
 | `LoaderAllocator` | `VirtualCallStubManager` | `pointer` | Pointer to the virtual-call stub manager |
 | `MethodDesc` | *(type size)* | `uint32` | Base size for mcIL classification |
 | `MethodDesc` | `ChunkIndex` | `uint8` | Offset of this MethodDesc relative to the end of its containing MethodDescChunk - in multiples of MethodDescAlignment |

docs/design/datacontracts/data-descriptor-meanings.json

@@ -330,7 +330,6 @@
     "LoaderAllocator.ObjectHandle": "Handle to the managed loader allocator object",
     "LoaderAllocator.ReferenceCount": "Reference count of the loader allocator",
     "LoaderAllocator.StaticsHeap": "Heap containing statics-related allocations",
-    "LoaderAllocator.StubHeap": "Heap containing runtime stubs",
     "LoaderAllocator.VirtualCallStubManager": "Pointer to the virtual-call stub manager",
     "LoaderCodeHeap.LoaderHeap": "Offset of the embedded `ExplicitControlLoaderHeap` within the `LoaderCodeHeap` object; adding this to the object's base address yields the loader heap address",
     "LoaderHeap.FirstBlock": "Pointer to the first loader-heap block",

src/coreclr/debug/daccess/request.cpp

@@ -2453,7 +2453,6 @@ 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->appDomainStage = STAGE_OPEN;
 
         appdomainData->dwId = DefaultADID;
@@ -3681,7 +3680,6 @@ static const char *LoaderAllocatorLoaderHeapNames[] =
     "LowFrequencyHeap",
     "HighFrequencyHeap",
     "StaticsHeap",
-    "StubHeap",
     "ExecutableHeap",
     "FixupPrecodeHeap",
     "NewStubPrecodeHeap",
@@ -3721,7 +3719,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/inc/eventtracebase.h

@@ -960,7 +960,7 @@ namespace ETW
         static VOID MethodJitted(MethodDesc *pMethodDesc, SString *namespaceOrClassName, SString *methodName, SString *methodSignature, PCODE pNativeCodeStartAddress, PrepareCodeConfig *pConfig);
         static VOID SendMethodDetailsEvent(MethodDesc *pMethodDesc);
         static VOID SendNonDuplicateMethodDetailsEvent(MethodDesc* pMethodDesc, MethodDescSet* set);
-        static VOID StubInitialized(ULONGLONG ullHelperStartAddress, LPCWSTR pHelperName);
+        static VOID StubInitialized(ULONGLONG ullHelperStartAddress, ULONG ulHelperSize, LPCWSTR pHelperName);
         static VOID MethodRestored(MethodDesc * pMethodDesc);
         static VOID DynamicMethodDestroyed(MethodDesc *pMethodDesc);
         static VOID LogMethodInstrumentationData(MethodDesc* method, uint32_t cbData, BYTE *data, TypeHandle* pTypeHandles, uint32_t numTypeHandles, MethodDesc** pMethods, uint32_t numMethods);
@@ -970,7 +970,7 @@ namespace ETW
         static VOID GetR2RGetEntryPoint(MethodDesc *pMethodDesc, PCODE pEntryPoint) {};
         static VOID MethodJitting(MethodDesc *pMethodDesc, COR_ILMETHOD_DECODER* methodDecoder, SString *namespaceOrClassName, SString *methodName, SString *methodSignature);
         static VOID MethodJitted(MethodDesc *pMethodDesc, SString *namespaceOrClassName, SString *methodName, SString *methodSignature, PCODE pNativeCodeStartAddress, PrepareCodeConfig *pConfig);
-        static VOID StubInitialized(ULONGLONG ullHelperStartAddress, LPCWSTR pHelperName) {};
+        static VOID StubInitialized(ULONGLONG ullHelperStartAddress, ULONG ulHelperSize, LPCWSTR pHelperName) {};
         static VOID MethodRestored(MethodDesc * pMethodDesc) {};
         static VOID DynamicMethodDestroyed(MethodDesc *pMethodDesc) {};
         static VOID LogMethodInstrumentationData(MethodDesc* method, uint32_t cbData, BYTE *data, TypeHandle* pTypeHandles, uint32_t numTypeHandles, MethodDesc** pMethods, uint32_t numMethods) {};

src/coreclr/inc/holder.h

@@ -1128,53 +1128,6 @@ struct CoTaskMemTraits final
 template<typename T>
 using CoTaskMemHolder = LifetimeHolder<CoTaskMemTraits<T>>;
 
-//-----------------------------------------------------------------------------
-// StubHolder : holder for runtime-emitted Stub-like objects.
-// On scope exit, calls DecRef through the executable-memory
-// writer-holder so the refcount field can be written.
-//
-// Note: StubHolder does NOT call IncRef on assignment - the caller owns
-// matching IncRef/DecRef pairing on the value it hands to the holder.
-//
-// Usage example:
-//
-//  {
-//      StubHolder<Stub> foo;
-//      foo = new Stub();
-//      foo->AddRef();
-//  } // foo->DecRef() on out of scope
-//-----------------------------------------------------------------------------
-template<typename T>
-class ExecutableWriterHolderNoLog;
-
-class ExecutableAllocator;
-
-template<typename T>
-struct StubTraits final
-{
-    using Type = T*;
-    static constexpr Type Default() { return nullptr; }
-    static void Free(Type value)
-    {
-        STATIC_CONTRACT_WRAPPER;
-        if (value != nullptr)
-        {
-#ifdef LOG_EXECUTABLE_ALLOCATOR_STATISTICS
-#ifdef HOST_UNIX
-            ExecutableAllocator::LogUsage(__FILE__, __LINE__, __PRETTY_FUNCTION__);
-#else
-            ExecutableAllocator::LogUsage(__FILE__, __LINE__, __FUNCTION__);
-#endif
-#endif // LOG_EXECUTABLE_ALLOCATOR_STATISTICS
-            ExecutableWriterHolderNoLog<T> stubWriterHolder(value, sizeof(T));
-            stubWriterHolder.GetRW()->DecRef();
-        }
-    }
-};
-
-template<typename T>
-using StubHolder = LifetimeHolder<StubTraits<T>>;
-
 //
 // We need the following methods to have volatile arguments, so that they can accept
 // raw pointers in addition to the results of the & operator on Volatile<T>.

src/coreclr/vm/appdomain.hpp

@@ -188,28 +188,14 @@ FORCEINLINE  void PinnedHeapHandleBlockHolder__StaticFree(PinnedHeapHandleBlockH
     pHolder->FreeData();
 };
 
-//--------------------------------------------------------------------------------------
-// Base class for domains. It provides an abstract way of finding the first assembly and
-// for creating assemblies in the domain. The system domain only has one assembly, it
-// contains the classes that are logically shared between domains. All other domains can
-// have multiple assemblies. Iteration is done be getting the first assembly and then
-// calling the Next() method on the assembly.
-//
-// The system domain should be as small as possible, it includes object, exceptions, etc.
-// which are the basic classes required to load other assemblies. All other classes
-// should be loaded into the domain. Of coarse there is a trade off between loading the
-// same classes multiple times, requiring all domains to load certain assemblies (working
-// set) and being able to specify specific versions.
-//
-
 #define LOW_FREQUENCY_HEAP_RESERVE_SIZE        (3 * minipal_getpagesize())
 #define LOW_FREQUENCY_HEAP_COMMIT_SIZE         (1 * minipal_getpagesize())
 
 #define HIGH_FREQUENCY_HEAP_RESERVE_SIZE       (8 * minipal_getpagesize())
 #define HIGH_FREQUENCY_HEAP_COMMIT_SIZE        (1 * minipal_getpagesize())
 
-#define STUB_HEAP_RESERVE_SIZE                 (3 * minipal_getpagesize())
-#define STUB_HEAP_COMMIT_SIZE                  (1 * minipal_getpagesize())
+#define EXECUTABLE_HEAP_RESERVE_SIZE           (3 * minipal_getpagesize())
+#define EXECUTABLE_HEAP_COMMIT_SIZE            (1 * minipal_getpagesize())
 
 #define STATIC_FIELD_HEAP_RESERVE_SIZE         (2 * minipal_getpagesize())
 #define STATIC_FIELD_HEAP_COMMIT_SIZE          (1 * minipal_getpagesize())
@@ -1297,7 +1283,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/array.cpp

@@ -864,7 +864,7 @@ class ArrayOpLinker : public ILStubLinker
     }
 };
 
-Stub *GenerateArrayOpStub(ArrayMethodDesc* pMD)
+PCODE GenerateArrayOpStub(ArrayMethodDesc* pMD)
 {
     STANDARD_VM_CONTRACT;
 
@@ -908,7 +908,7 @@ Stub *GenerateArrayOpStub(ArrayMethodDesc* pMD)
                                                             NULL,
                                                             &sl);
 
-    return Stub::NewStub(JitILStub(pStubMD));
+    return JitILStub(pStubMD);
 }
 
 

src/coreclr/vm/array.h

@@ -14,7 +14,7 @@
 class MethodTable;
 
 
-Stub *GenerateArrayOpStub(ArrayMethodDesc* pMD);
+PCODE GenerateArrayOpStub(ArrayMethodDesc* pMD);
 
 
 

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/cgensys.h

@@ -11,7 +11,6 @@
 #define __cgensys_h__
 
 class MethodDesc;
-class Stub;
 class Thread;
 class CrawlFrame;
 struct EE_ILEXCEPTION_CLAUSE;

src/coreclr/vm/class.cpp

@@ -81,29 +81,6 @@ void EEClass::Destruct()
 #endif // FEATURE_COMINTEROP_UNMANAGED_ACTIVATION
 #endif // FEATURE_COMINTEROP
 
-
-    if (IsDelegate())
-    {
-        DelegateEEClass* pDelegateEEClass = (DelegateEEClass*)this;
-        for (Stub* pThunk : {pDelegateEEClass->m_pStaticCallStub, pDelegateEEClass->m_pInstRetBuffCallStub})
-        {
-            if (pThunk == nullptr)
-                continue;
-
-            _ASSERTE(pThunk->IsShuffleThunk());
-
-            if (pThunk->HasExternalEntryPoint()) // IL thunk
-            {
-                pThunk->DecRef();
-            }
-            else
-            {
-                ExecutableWriterHolder<Stub> stubWriterHolder(pThunk, sizeof(Stub));
-                stubWriterHolder.GetRW()->DecRef();
-            }
-        }
-    }
-
 #ifdef FEATURE_COMINTEROP
     if (GetSparseCOMInteropVTableMap() != NULL)
         delete GetSparseCOMInteropVTableMap();

src/coreclr/vm/class.h

@@ -77,7 +77,6 @@ class   MethodDescChunk;
 class   MethodTable;
 class   Module;
 class   Object;
-class   Stub;
 enum class AsyncMethodFlags;
 class   Substitution;
 class   SystemDomain;
@@ -1898,8 +1897,8 @@ class DelegateEEClass : public EEClass
 {
 public:
     DAC_ALIGNAS(EEClass) // Align the first member to the alignment of the base class
-    PTR_Stub                         m_pStaticCallStub;
-    PTR_Stub                         m_pInstRetBuffCallStub;
+    PCODE                            m_pStaticCallStub;
+    PCODE                            m_pInstRetBuffCallStub;
     PTR_MethodDesc                   m_pInvokeMethod;
     PCODE                            m_pMultiCastInvokeStub;
     UMThunkMarshInfo*                m_pUMThunkMarshInfo;
@@ -1920,9 +1919,6 @@ class DelegateEEClass : public EEClass
         LIMITED_METHOD_CONTRACT;
         // Note: Memory allocated on loader heap is zero filled
     }
-
-    // We need a LoaderHeap that lives at least as long as the DelegateEEClass, but ideally no longer
-    LoaderHeap *GetStubHeap();
 #endif // !DACCESS_COMPILE
 
 };

src/coreclr/vm/classcompat.h

@@ -48,7 +48,6 @@ class   MethodNameHash;
 class   MethodTable;
 class   Module;
 class   Object;
-class   Stub;
 class   Substitution;
 class   SystemDomain;
 class   TypeHandle;