Create a single copy of stub templates (#114462)

Instead of generating stub templates by running the code page generation function for each stub code region that is generated, map a single file into memory in multiple locations instead. This logic is architected so that it can fall back to the previous model of using the double mapping logic to generate the stubs.

We implement 3 schemes for finding the to use as mapping data.
1. On apple platforms, we compile the stubs into the coreclr Mach-O file, and use the virtual memory manager support for mapping memory from the coreclr binary into various locations on the heap.
3. On Unix platforms that are not Apple derived we use an anonymous in memory file just like our normal executable allocation path.
3. On Linux platforms, we *can* compile the stubs into the coreclr ELF file, and then use the `dladdr` and `dl_iterate_phdr` functionality to find the file name of the coreclr binary and the section that contains it, and then we can use mmap to map from the file directly into memory. This mode is disabled by default as it doesn't support all scenarios, but it does allow for testing of the majority of the logic used on Apple platforms on a Linux machine.
4. On Windows platforms, we currently do not yet support this mode.

Author: davidwrighton

src/coreclr/clrdefinitions.cmake

@@ -218,6 +218,10 @@ 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,6 +182,9 @@ 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();
 
@@ -262,6 +265,18 @@ 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,10 +455,19 @@ 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 GetOSStubPageSize() bytes away. In addition there is an
+// with memory which is GetStubCodePageSize() bytes away. In addition there is an
 // ability to free is via a "backout" mechanism that is not considered to have good performance.
 //
 //===============================================================================
@@ -492,16 +501,13 @@ class UnlockedInterleavedLoaderHeap : public UnlockedLoaderHeapBase
 
     InterleavedStubFreeListNode  *m_pFreeListHead;
 
-public:
-public:
-    void                (*m_codePageGenerator)(BYTE* pageBase, BYTE* pageBaseRX, SIZE_T size);
+    const InterleavedLoaderHeapConfig *m_pConfig;
 
 #ifndef DACCESS_COMPILE
 protected:
     UnlockedInterleavedLoaderHeap(
         RangeList *pRangeList,
-        void (*codePageGenerator)(BYTE* pageBase, BYTE* pageBaseRX, SIZE_T size),
-        DWORD dwGranularity);
+        const InterleavedLoaderHeapConfig *pConfig);
 
     virtual ~UnlockedInterleavedLoaderHeap();
 #endif
@@ -1039,13 +1045,11 @@ class InterleavedLoaderHeap : public UnlockedInterleavedLoaderHeap
 public:
     InterleavedLoaderHeap(RangeList *pRangeList,
                BOOL fUnlocked,
-               void (*codePageGenerator)(BYTE* pageBase, BYTE* pageBaseRX, SIZE_T size),
-               DWORD dwGranularity
+               const InterleavedLoaderHeapConfig *pConfig
                )
       : UnlockedInterleavedLoaderHeap(
                            pRangeList,
-                           codePageGenerator,
-                           dwGranularity),
+                           pConfig),
         m_CriticalSection(fUnlocked ? NULL : CreateLoaderHeapLock())
     {
         WRAPPER_NO_CONTRACT;