Make it work on Arm64, and detect cases where we use the initial libcoreclr template in ways that are unsafe.

Author: davidwrighton

src/coreclr/clrdefinitions.cmake

@@ -217,7 +217,9 @@ if (FEATURE_STUBPRECODE_DYNAMIC_HELPERS)
   add_definitions(-DFEATURE_STUBPRECODE_DYNAMIC_HELPERS)
 endif()
 
-add_definitions(-DFEATURE_MAP_THUNKS_FROM_IMAGE)
+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

src/coreclr/minipal/Unix/doublemapping.cpp

@@ -261,14 +261,15 @@ bool VMToOSInterface::ReleaseRWMapping(void* pStart, size_t size)
 }
 
 #ifndef TARGET_APPLE
-#define MAX_TEMPLATE_THUNK_TYPES 8 // Maximum number of times the CreateTemplate api can be called
+#define MAX_TEMPLATE_THUNK_TYPES 3 // Maximum number of times the CreateTemplate api can be called
 struct TemplateThunkMappingData
 {
     int fdImage;
     off_t offsetInFileOfStartOfSection;
     void* addrOfStartOfSection; // Always NULL if the template mapping data could not be initialized
     void* addrOfEndOfSection;
     bool imageTemplates;
+    int templatesCreated;
     off_t nonImageTemplateCurrent;
 };
 
@@ -281,6 +282,8 @@ struct InitializeTemplateThunkLocals
 
 static TemplateThunkMappingData *s_pThunkData = NULL;
 
+#ifdef FEATURE_MAP_THUNKS_FROM_IMAGE
+
 static Elf32_Word Elf32_WordMin(Elf32_Word left, Elf32_Word  right)
 {
     return left < right ? left : right;
@@ -338,6 +341,7 @@ static int InitializeTemplateThunkMappingDataPhdrCallback(struct dl_phdr_info *i
     // This isn't the interesting .so
     return 0;
 }
+#endif // FEATURE_MAP_THUNKS_FROM_IMAGE
 
 TemplateThunkMappingData *InitializeTemplateThunkMappingData(void* pTemplate)
 {
@@ -349,11 +353,14 @@ TemplateThunkMappingData *InitializeTemplateThunkMappingData(void* pTemplate)
     locals.data.addrOfEndOfSection = NULL;
     locals.data.imageTemplates = false;
     locals.data.nonImageTemplateCurrent = 0;
+    locals.data.templatesCreated = 0;
 
+#ifdef FEATURE_MAP_THUNKS_FROM_IMAGE
     if (dladdr(pTemplate, &locals.info) != 0)
     {
         dl_iterate_phdr(InitializeTemplateThunkMappingDataPhdrCallback, &locals);
     }
+#endif // FEATURE_MAP_THUNKS_FROM_IMAGE
 
     if (locals.data.addrOfStartOfSection == NULL)
     {
@@ -382,7 +389,7 @@ TemplateThunkMappingData *InitializeTemplateThunkMappingData(void* pTemplate)
 #endif
         if (fd != -1)
         {
-            off_t maxFileSize = MAX_TEMPLATE_THUNK_TYPES * 0x10000;
+            off_t maxFileSize = MAX_TEMPLATE_THUNK_TYPES * 0x10000; // The largest page size we support currently is 64KB.
             if (ftruncate(fd, maxFileSize) == -1) // Reserve a decent size chunk of logical memory for these things.
             {
                 close(fd);
@@ -445,6 +452,9 @@ void* VMToOSInterface::CreateTemplate(void* pImageTemplate, size_t templateSize,
         return NULL;
     }
 
+    int templatesCreated = __atomic_add_fetch(&pThunkData->templatesCreated, 1, __ATOMIC_SEQ_CST);
+    assert(templatesCreated <= MAX_TEMPLATE_THUNK_TYPES);
+
     if (!pThunkData->imageTemplates)
     {
         // Need to allocate a memory mapped region to fill in the data

src/coreclr/vm/arm64/thunktemplates.S

@@ -5,31 +5,33 @@
 #include "asmconstants.h"
 
 #ifdef FEATURE_MAP_THUNKS_FROM_IMAGE
-
 #define POINTER_SIZE 0x08
+// Since Arm64 supports 4KB, 16KB and 64KB page sizes, as the templates is only defined for 16KB page size, this cannot be used
+// in a general purpose Linux environment. However it CAN be used on Apple platforms, which specify that 16KB is the system standard
+// page size.
 
 #define THUNKS_MAP_SIZE 0x4000
 
 #define PAGE_SIZE 0x4000
 #define PAGE_SIZE_LOG2 14
 
 
-#define DATA_SLOT(stub, field, thunksPerPage, thunkTemplateName) . - (. - C_FUNC(thunkTemplateName)) + \THUNKS_MAP_SIZE + stub##Data__##field + IN_PAGE_INDEX * STUB_THUNK_CODESIZE
+#define DATA_SLOT(stub, field, thunkSize, thunkTemplateName) C_FUNC(thunkTemplateName) + THUNKS_MAP_SIZE + stub##Data__##field + IN_PAGE_INDEX * thunkSize
 
 // ----------
 // StubPrecode
 // ----------
 
 #define STUB_PRECODE_CODESIZE 0x18 // 3 instructions, 4 bytes each (and we also have 12 bytes of padding)
 #define STUB_PRECODE_DATASIZE 0x18 // 2 qwords + 1 byte
-.set STUB_PRECODE_NUM_THUNKS_PER_MAPPING,(THUNKS_MAP_SIZE / STUB_PRECODE_CODESIZE)
+.set STUB_PRECODE_NUM_THUNKS_PER_MAPPING, (THUNKS_MAP_SIZE / STUB_PRECODE_CODESIZE)
 
 .macro THUNKS_BLOCK_STUB_PRECODE
     IN_PAGE_INDEX = 0
-    .rept STUB_PRECODE_NUM_THUNKS_PER_MAP
+    .rept STUB_PRECODE_NUM_THUNKS_PER_MAPPING
 
-    ldr x10, DATA_SLOT(StubPrecode, Target, STUB_PRECODE_NUM_THUNKS_PER_MAPPING, StubPrecodeCodeTemplate)
-    ldr x12, DATA_SLOT(StubPrecode, SecretParam, STUB_PRECODE_NUM_THUNKS_PER_MAPPING, StubPrecodeCodeTemplate)
+    ldr x10, DATA_SLOT(StubPrecode, Target, STUB_PRECODE_CODESIZE, StubPrecodeCodeTemplate)
+    ldr x12, DATA_SLOT(StubPrecode, SecretParam, STUB_PRECODE_CODESIZE, StubPrecodeCodeTemplate)
     br x10
 
     brk     0xf000      // Stubs need to be 24-byte in size to allow for the data to be 2 pointers + 1 byte
@@ -53,18 +55,17 @@ LEAF_END_MARKED StubPrecodeCodeTemplate, _TEXT
 #define FIXUP_PRECODE_CODESIZE 0x18 // 5 instructions, 4 bytes each (and we also have 4 bytes of padding)
 #define FIXUP_PRECODE_DATASIZE 0x18 // 3 qwords
 .set FIXUP_PRECODE_NUM_THUNKS_PER_MAPPING,(THUNKS_MAP_SIZE / FIXUP_PRECODE_CODESIZE)
-#define FIXUP_PRECODE_NUM_THUNKS_PER_MAPPING (THUNKS_MAP_SIZE / FIXUP_PRECODE_CODESIZE)
 
 .macro THUNKS_BLOCK_FIXUP_PRECODE
     IN_PAGE_INDEX = 0
     .rept FIXUP_PRECODE_NUM_THUNKS_PER_MAPPING
 
-    ldr x11, DATA_SLOT(FixupPrecode, Target, FIXUP_PRECODE_NUM_THUNKS_PER_MAPPING, FixupPrecodeCodeTemplate)
+    ldr x11, DATA_SLOT(FixupPrecode, Target, FIXUP_PRECODE_CODESIZE, FixupPrecodeCodeTemplate)
     br  x11
-    ldr x12, DATA_SLOT(FixupPrecode, MethodDesc, FIXUP_PRECODE_NUM_THUNKS_PER_MAPPING, FixupPrecodeCodeTemplate)
-    ldr x11, DATA_SLOT(FixupPrecode, PrecodeFixupThunk, FIXUP_PRECODE_NUM_THUNKS_PER_MAPPING, FixupPrecodeCodeTemplate)
+    ldr x12, DATA_SLOT(FixupPrecode, MethodDesc, FIXUP_PRECODE_CODESIZE, FixupPrecodeCodeTemplate)
+    ldr x11, DATA_SLOT(FixupPrecode, PrecodeFixupThunk, FIXUP_PRECODE_CODESIZE, FixupPrecodeCodeTemplate)
     br  x11        
-    brk     0xf000      // Stubs need to be 24-byte in size to allow for the data to be 2 pointers
+    brk     0xf000      // Stubs need to be 24-byte in size to allow for the data to be 3 pointers
 
     IN_PAGE_INDEX = IN_PAGE_INDEX + 1
     .endr
@@ -82,23 +83,23 @@ LEAF_END_MARKED FixupPrecodeCodeTemplate, _TEXT
 
 #define CALLCOUNTING_CODESIZE 0x28 // 5 instructions, 4 bytes each (and we also have 4 bytes of padding)
 #define CALLCOUNTING_DATASIZE 0x18 // 3 qwords
-#define CALLCOUNTING_NUM_THUNKS_PER_MAPPING (THUNKS_MAP_SIZE / CALLCOUNTING_CODESIZE)
+.set CALLCOUNTING_NUM_THUNKS_PER_MAPPING, (THUNKS_MAP_SIZE / CALLCOUNTING_CODESIZE)
 
 .macro THUNKS_BLOCK_CALLCOUNTING
     IN_PAGE_INDEX = 0
     .rept CALLCOUNTING_NUM_THUNKS_PER_MAPPING
 
-        ldr  x9, DATA_SLOT(CallCountingStub, RemainingCallCountCell)
+        ldr  x9, DATA_SLOT(CallCountingStub, RemainingCallCountCell, CALLCOUNTING_CODESIZE, CallCountingStubCodeTemplate)
         ldrh w10, [x9]
         subs w10, w10, #1
         strh w10, [x9]
-        beq LOCAL_LABEL(CountReachedZero\IN_PAGE_INDEX)
-        ldr  x9, DATA_SLOT(CallCountingStub, TargetForMethod)
+        beq 0f
+        ldr  x9, DATA_SLOT(CallCountingStub, TargetForMethod, CALLCOUNTING_CODESIZE, CallCountingStubCodeTemplate)
         br   x9
-LOCAL_LABEL(CountReachedZero\IN_PAGE_INDEX):
-        ldr  x10, DATA_SLOT(CallCountingStub, TargetForThresholdReached)
+0:
+        ldr  x10, DATA_SLOT(CallCountingStub, TargetForThresholdReached, CALLCOUNTING_CODESIZE, CallCountingStubCodeTemplate)
         br   x10
-        brk     0xf000      // Stubs need to be 16-byte in size to allow for the data to be 2 pointers
+        brk     0xf000      // Stubs need to be 40-byte in size to allow for the data to be pointer aligned
 
     IN_PAGE_INDEX = IN_PAGE_INDEX + 1
     .endr
@@ -109,8 +110,11 @@ LOCAL_LABEL(CountReachedZero\IN_PAGE_INDEX):
 LEAF_ENTRY CallCountingStubCodeTemplate
     THUNKS_BLOCK_CALLCOUNTING
 LEAF_END_MARKED CallCountingStubCodeTemplate, _TEXT
+#endif
 
-#else
+#ifdef DATA_SLOT
+#undef DATA_SLOT
+#endif
 #define DATA_SLOT(stub, field) . - (. - C_FUNC(stub##Code\STUB_PAGE_SIZE)) + \STUB_PAGE_SIZE + stub##Data__##field
 
     .irp STUB_PAGE_SIZE, 16384, 32768, 65536
@@ -144,4 +148,3 @@ LOCAL_LABEL(CountReachedZero\STUB_PAGE_SIZE):
     LEAF_END_MARKED CallCountingStubCode\STUB_PAGE_SIZE
 
     .endr
-#endif

src/coreclr/vm/callcounting.cpp

@@ -318,6 +318,12 @@ void CallCountingStub::StaticInitialize()
             EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(COR_E_EXECUTIONENGINE, W("Unsupported OS page size"));
     }
     #undef ENUM_PAGE_SIZE
+
+    if (CallCountingStubCodeTemplate != NULL && pageSize != 0x4000)
+    {
+        // This should fail if the template is used on a platform which doesn't support the supported page size for templates
+        ThrowHR(COR_E_EXECUTIONENGINE);
+    }
 #else
     _ASSERTE((SIZE_T)((BYTE*)CallCountingStubCode_End - (BYTE*)CallCountingStubCode) <= CallCountingStub::CodeSize);
 #endif

src/coreclr/vm/precode.cpp

@@ -523,6 +523,13 @@ void StubPrecode::StaticInitialize()
         default:
             EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(COR_E_EXECUTIONENGINE, W("Unsupported OS page size"));
     }
+
+    if (StubPrecodeCodeTemplate != NULL && pageSize != 0x4000)
+    {
+        // This should fail if the template is used on a platform which doesn't support the supported page size for templates
+        ThrowHR(COR_E_EXECUTIONENGINE);
+    }
+
     #undef ENUM_PAGE_SIZE
 #else
     _ASSERTE((SIZE_T)((BYTE*)StubPrecodeCode_End - (BYTE*)StubPrecodeCode) <= StubPrecode::CodeSize);
@@ -663,6 +670,12 @@ void FixupPrecode::StaticInitialize()
             EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(COR_E_EXECUTIONENGINE, W("Unsupported OS page size"));
     }
     #undef ENUM_PAGE_SIZE
+
+    if (FixupPrecodeCodeTemplate != NULL && pageSize != 0x4000)
+    {
+        // This should fail if the template is used on a platform which doesn't support the supported page size for templates
+        ThrowHR(COR_E_EXECUTIONENGINE);
+    }
 #else
     _ASSERTE((SIZE_T)((BYTE*)FixupPrecodeCode_End - (BYTE*)FixupPrecodeCode) <= FixupPrecode::CodeSize);
 #endif