Add writeable holders for executable memory

src/coreclr/inc/executableallocator.h

@@ -0,0 +1,72 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+
+//
+// Allocator and holders for double mapped executable memory
+//
+
+#pragma once
+
+#include "utilcode.h"
+#include "ex.h"
+
+// Holder class to map read-execute memory as read-write so that it can be modified without using read-write-execute mapping.
+// At the moment the implementation is dummy, returning the same addresses for both cases and expecting them to be read-write-execute.
+// The class uses the move semantics to ensure proper unmapping in case of re-assigning of the holder value.
+template<typename T>
+class ExecutableWriterHolder
+{
+    T *m_addressRX;
+    T *m_addressRW;
+
+    void Move(ExecutableWriterHolder& other)
+    {
+        m_addressRX = other.m_addressRX;
+        m_addressRW = other.m_addressRW;
+        other.m_addressRX = NULL;
+        other.m_addressRW = NULL;
+    }
+
+    void Unmap()
+    {
+        // TODO: this will be added with the double mapped allocator addition 
+    }
+
+public:
+    ExecutableWriterHolder(const ExecutableWriterHolder& other) = delete;
+    ExecutableWriterHolder& operator=(const ExecutableWriterHolder& other) = delete;
+
+    ExecutableWriterHolder(ExecutableWriterHolder&& other)
+    {
+        Move(other);
+    }
+
+    ExecutableWriterHolder& operator=(ExecutableWriterHolder&& other)
+    {
+        Unmap();
+        Move(other);
+        return *this;
+    }
+
+    ExecutableWriterHolder() : m_addressRX(nullptr), m_addressRW(nullptr)
+    {
+    }
+
+    ExecutableWriterHolder(T* addressRX, size_t size)
+    {
+        m_addressRX = addressRX;
+        m_addressRW = addressRX;
+    }
+
+    ~ExecutableWriterHolder()
+    {
+        Unmap();
+    }
+
+    // Get the writeable address
+    inline T *GetRW() const
+    {
+        return m_addressRW;
+    }
+};

src/coreclr/inc/holder.h

@@ -934,11 +934,17 @@ using NonVMComHolder = SpecializedWrapper<_TYPE, DoTheRelease<_TYPE>>;
 //  } // foo->DecRef() on out of scope
 //
 //-----------------------------------------------------------------------------
+template<typename _TYPE>
+class ExecutableWriterHolder;
+
 template <typename TYPE>
 FORCEINLINE void StubRelease(TYPE* value)
 {
     if (value)
-        value->DecRef();
+    {
+        ExecutableWriterHolder<TYPE> stubWriterHolder(value, sizeof(TYPE));
+        stubWriterHolder.GetRW()->DecRef();
+    }
 }
 
 template<typename _TYPE>

src/coreclr/inc/loaderheap.h

@@ -16,6 +16,7 @@
 
 #include "utilcode.h"
 #include "ex.h"
+#include "executableallocator.h"
 
 //==============================================================================
 // Interface used to back out loader heap allocations.

src/coreclr/utilcode/loaderheap.cpp

@@ -1330,8 +1330,14 @@ void *UnlockedLoaderHeap::UnlockedAllocMem_NoThrow(size_t dwSize
         if (pData)
         {
 #ifdef _DEBUG
+            BYTE *pAllocatedBytes = (BYTE*)pData;
+            ExecutableWriterHolder<void> dataWriterHolder;
+            if (m_Options & LHF_EXECUTABLE)
+            {
+                dataWriterHolder = ExecutableWriterHolder<void>(pData, dwSize);
+                pAllocatedBytes = (BYTE *)dataWriterHolder.GetRW();
+            }
 
-            BYTE *pAllocatedBytes = (BYTE *)pData;
 #if LOADER_HEAP_DEBUG_BOUNDARY > 0
             // Don't fill the memory we allocated - it is assumed to be zeroed - fill the memory after it
             memset(pAllocatedBytes + dwRequestedSize, 0xEE, LOADER_HEAP_DEBUG_BOUNDARY);
@@ -1344,7 +1350,7 @@ void *UnlockedLoaderHeap::UnlockedAllocMem_NoThrow(size_t dwSize
 
             if (!m_fExplicitControl)
             {
-                LoaderHeapValidationTag *pTag = AllocMem_GetTag(pData, dwRequestedSize);
+                LoaderHeapValidationTag *pTag = AllocMem_GetTag(pAllocatedBytes, dwRequestedSize);
                 pTag->m_allocationType  = kAllocMem;
                 pTag->m_dwRequestedSize = dwRequestedSize;
                 pTag->m_szFile          = szFile;
@@ -1514,7 +1520,14 @@ void UnlockedLoaderHeap::UnlockedBackoutMem(void *pMem,
     {
         // Cool. This was the last block allocated. We can just undo the allocation instead
         // of going to the freelist.
-        memset(pMem, 0x00, dwSize); // Fill freed region with 0
+        void *pMemRW = pMem;
+        ExecutableWriterHolder<void> memWriterHolder;
+        if (m_Options & LHF_EXECUTABLE)
+        {
+            memWriterHolder = ExecutableWriterHolder<void>(pMem, dwSize);
+            pMemRW = memWriterHolder.GetRW();
+        }
+        memset(pMemRW, 0x00, dwSize); // Fill freed region with 0
         m_pAllocPtr = (BYTE*)pMem;
     }
     else
@@ -1626,7 +1639,14 @@ void *UnlockedLoaderHeap::UnlockedAllocAlignedMem_NoThrow(size_t  dwRequestedSiz
     ((BYTE*&)pResult) += extra;
 
 #ifdef _DEBUG
-     BYTE *pAllocatedBytes = (BYTE *)pResult;
+    BYTE *pAllocatedBytes = (BYTE *)pResult;
+    ExecutableWriterHolder<void> resultWriterHolder;
+    if (m_Options & LHF_EXECUTABLE)
+    {
+        resultWriterHolder = ExecutableWriterHolder<void>(pResult, dwSize - extra);
+        pAllocatedBytes = (BYTE *)resultWriterHolder.GetRW();
+    }
+
 #if LOADER_HEAP_DEBUG_BOUNDARY > 0
     // Don't fill the entire memory - we assume it is all zeroed -just the memory after our alloc
     memset(pAllocatedBytes + dwRequestedSize, 0xee, LOADER_HEAP_DEBUG_BOUNDARY);
@@ -1656,7 +1676,7 @@ void *UnlockedLoaderHeap::UnlockedAllocAlignedMem_NoThrow(size_t  dwRequestedSiz
 
     if (!m_fExplicitControl)
     {
-        LoaderHeapValidationTag *pTag = AllocMem_GetTag(((BYTE*)pResult) - extra, dwRequestedSize + extra);
+        LoaderHeapValidationTag *pTag = AllocMem_GetTag(pAllocatedBytes - extra, dwRequestedSize + extra);
         pTag->m_allocationType  = kAllocMem;
         pTag->m_dwRequestedSize = dwRequestedSize + extra;
         pTag->m_szFile          = szFile;