Revert "Create a single copy of stub templates (dotnet#114462)" (dotnet#115665)

This reverts commit ac760bf.

Author: thaystg

src/coreclr/clrdefinitions.cmake

@@ -218,10 +218,6 @@ if (FEATURE_STUBPRECODE_DYNAMIC_HELPERS)
   add_definitions(-DFEATURE_STUBPRECODE_DYNAMIC_HELPERS)
 endif()
 
-if (CLR_CMAKE_TARGET_APPLE)
-  add_definitions(-DFEATURE_MAP_THUNKS_FROM_IMAGE)
-endif()
-
 # Use this function to enable building with a specific target OS and architecture set of defines
 # This is known to work for the set of defines used by the JIT and gcinfo, it is not likely correct for
 # other components of the runtime

src/coreclr/inc/executableallocator.h

@@ -182,9 +182,6 @@ class ExecutableAllocator
     // Return true if double mapping is enabled.
     static bool IsDoubleMappingEnabled();
 
-    // Release memory allocated via DoubleMapping for either templates or normal double mapped data
-    void ReleaseWorker(void* pRX, bool releaseTemplate);
-
     // Initialize the allocator instance
     bool Initialize();
 
@@ -265,18 +262,6 @@ class ExecutableAllocator
 
     // Unmap the RW mapping at the specified address
     void UnmapRW(void* pRW);
-
-    // Allocate thunks from a template. pTemplate is the return value from CreateTemplate
-    void* AllocateThunksFromTemplate(void *pTemplate, size_t templateSize);
-
-    // Free a set of thunks allocated from templates. pThunks must have been returned from AllocateThunksFromTemplate
-    void FreeThunksFromTemplate(void *pThunks, size_t templateSize);
-
-    // Create a template
-    // If templateInImage is not null, it will attempt to use it as the template, otherwise it will create an temporary in memory file to serve as the template
-    // Some OS/Architectures may/may not be able to work with this, so this api is permitted to return NULL, and callers should have an alternate approach using
-    // the codePageGenerator directly.
-    void* CreateTemplate(void* templateInImage, size_t templateSize, void (*codePageGenerator)(uint8_t* pageBase, uint8_t* pageBaseRX, size_t size));
 };
 
 #define ExecutableWriterHolder ExecutableWriterHolderNoLog

src/coreclr/inc/loaderheap.h

@@ -455,19 +455,10 @@ class UnlockedLoaderHeap : public UnlockedLoaderHeapBase
     static void WeGotAFaultNowWhat(UnlockedLoaderHeap *pHeap);
 };
 
-struct InterleavedLoaderHeapConfig
-{
-    uint32_t StubSize;
-    void* Template;
-    void (*CodePageGenerator)(uint8_t* pageBase, uint8_t* pageBaseRX, size_t size);
-};
-
-void InitializeLoaderHeapConfig(InterleavedLoaderHeapConfig *pConfig, size_t stubSize, void* templateInImage, void (*codePageGenerator)(uint8_t* pageBase, uint8_t* pageBaseRX, size_t size));
-
 //===============================================================================
 // This is the base class for InterleavedLoaderHeap It's used as a simple
 // allocator for stubs in a scheme where each stub is a small fixed size, and is paired
-// with memory which is GetStubCodePageSize() bytes away. In addition there is an
+// with memory which is GetOSStubPageSize() bytes away. In addition there is an
 // ability to free is via a "backout" mechanism that is not considered to have good performance.
 //
 //===============================================================================
@@ -501,13 +492,16 @@ class UnlockedInterleavedLoaderHeap : public UnlockedLoaderHeapBase
 
     InterleavedStubFreeListNode  *m_pFreeListHead;
 
-    const InterleavedLoaderHeapConfig *m_pConfig;
+public:
+public:
+    void                (*m_codePageGenerator)(BYTE* pageBase, BYTE* pageBaseRX, SIZE_T size);
 
 #ifndef DACCESS_COMPILE
 protected:
     UnlockedInterleavedLoaderHeap(
         RangeList *pRangeList,
-        const InterleavedLoaderHeapConfig *pConfig);
+        void (*codePageGenerator)(BYTE* pageBase, BYTE* pageBaseRX, SIZE_T size),
+        DWORD dwGranularity);
 
     virtual ~UnlockedInterleavedLoaderHeap();
 #endif
@@ -1045,11 +1039,13 @@ class InterleavedLoaderHeap : public UnlockedInterleavedLoaderHeap
 public:
     InterleavedLoaderHeap(RangeList *pRangeList,
                BOOL fUnlocked,
-               const InterleavedLoaderHeapConfig *pConfig
+               void (*codePageGenerator)(BYTE* pageBase, BYTE* pageBaseRX, SIZE_T size),
+               DWORD dwGranularity
                )
       : UnlockedInterleavedLoaderHeap(
                            pRangeList,
-                           pConfig),
+                           codePageGenerator,
+                           dwGranularity),
         m_CriticalSection(fUnlocked ? NULL : CreateLoaderHeapLock())
     {
         WRAPPER_NO_CONTRACT;