Implement FEATURE_DOUBLE_ALIGNMENT_HINT for linux-x86

Author: filipnavara

src/coreclr/pal/inc/unixasmmacros.inc

@@ -43,6 +43,8 @@
 #define GC_ALLOC_ALIGN8_BIAS        4
 #define GC_ALLOC_ALIGN8             8
 
+#define G_FREE_OBJECT_METHOD_TABLE  g_pFreeObjectMethodTable
+
 #if defined(HOST_X86)
 #include "unixasmmacrosx86.inc"
 #elif defined(HOST_AMD64)

src/coreclr/runtime/i386/AllocFast.S

@@ -4,55 +4,108 @@
 .intel_syntax noprefix
 #include "AsmMacros_Shared.h"
 
-// Allocate non-array, non-finalizable object. If the allocation doesn't fit into the current thread's
-// allocation context then automatically fallback to the slow allocation path.
+// Shared code for RhpNewFast, RhpNewFastAlign8 and RhpNewFastMisalign
 //  ECX == MethodTable
-LEAF_ENTRY RhpNewFast, _TEXT
+.macro NEW_FAST Variation
 
         // edx = ee_alloc_context pointer, TRASHES eax
         INLINE_GET_ALLOC_CONTEXT
 
-        //
-        // ecx contains MethodTable pointer
-        //
+        // When doing aligned or misaligned allocation we first check
+        // the alignment and skip to the regular path if it's already
+        // matching the expectation.
+        // Otherwise, we try to allocate size + ASM_MIN_OBJECT_SIZE and
+        // then prepend a dummy free object at the beginning of the
+        // allocation.
+.ifnc \Variation,
+        mov         eax, [edx + OFFSETOF__ee_alloc_context__alloc_ptr]
+        test        eax, 7
+.ifc \Variation,Align8
+        jz          1f // AlreadyAligned
+.else // Variation == "Misalign"
+        jnz         1f // AlreadyAligned
+.endif
+
         mov         eax, [ecx + OFFSETOF__MethodTable__m_uBaseSize]
+        add         eax, ASM_MIN_OBJECT_SIZE
+        add         eax, [edx + OFFSETOF__ee_alloc_context__alloc_ptr]
+        cmp         eax, [edx + OFFSETOF__ee_alloc_context__combined_limit]
+        ja          2f // AllocFailed
+        mov         [edx + OFFSETOF__ee_alloc_context__alloc_ptr], eax
 
-        //
-        // eax: base size
-        // ecx: MethodTable pointer
-        // edx: ee_alloc_context pointer
-        //
+        // calc the new object pointer and initialize it
+        sub         eax, [ecx + OFFSETOF__MethodTable__m_uBaseSize]
+        mov         [eax + OFFSETOF__Object__m_pEEType], ecx
+
+        // initialize the padding object preceeding the new object
+        PREPARE_EXTERNAL_VAR G_FREE_OBJECT_METHOD_TABLE, edx
+        mov         [eax + OFFSETOF__Object__m_pEEType - ASM_MIN_OBJECT_SIZE], edx
+        mov         dword ptr [eax + OFFSETOF__Array__m_Length - ASM_MIN_OBJECT_SIZE], 0
+
+        ret
+.endif // Variation != ""
 
+1: // AlreadyAligned
+        mov         eax, [ecx + OFFSETOF__MethodTable__m_uBaseSize]
         add         eax, [edx + OFFSETOF__ee_alloc_context__alloc_ptr]
         cmp         eax, [edx + OFFSETOF__ee_alloc_context__combined_limit]
-        ja          AllocFailed
-
-        // set the new alloc pointer
+        ja          2f // AllocFailed
         mov         [edx + OFFSETOF__ee_alloc_context__alloc_ptr], eax
 
-        // calc the new object pointer
+        // calc the new object pointer and initialize it
         sub         eax, [ecx + OFFSETOF__MethodTable__m_uBaseSize]
-
-        // set the new object's MethodTable pointer
         mov         [eax + OFFSETOF__Object__m_pEEType], ecx
-        ret
 
-AllocFailed:
+        ret
 
-        xor         edx, edx                                        // Flags
+2: // AllocFailed
+.ifc \Variation,
+        xor         edx, edx
+.else
+.ifc \Variation,Align8
+        mov         edx, GC_ALLOC_ALIGN8
+.else
+        mov         edx, GC_ALLOC_ALIGN8 + GC_ALLOC_ALIGN8_BIAS
+.endif
+.endif
         jmp         RhpNewObject
 
+.endm
+
+// Allocate non-array, non-finalizable object. If the allocation doesn't fit into the current thread's
+// allocation context then automatically fallback to the slow allocation path.
+//  ECX == MethodTable
+LEAF_ENTRY RhpNewFast, _TEXT
+        NEW_FAST
 LEAF_END RhpNewFast, _TEXT
 
+// Allocate simple object (not finalizable, array or value type) on an 8 byte boundary.
+//  ECX == MethodTable
+LEAF_ENTRY RhpNewFastAlign8, _TEXT
+        NEW_FAST Align8
+LEAF_END RhpNewFastAlign8, _TEXT
+
+// Allocate a value type object (i.e. box it) on an 8 byte boundary + 4 (so that the value type payload
+// itself is 8 byte aligned).
+//  ECX == MethodTable
+LEAF_ENTRY RhpNewFastMisalign, _TEXT
+        NEW_FAST Misalign
+LEAF_END RhpNewFastMisalign, _TEXT
+
 // Allocate non-array object with finalizer.
 //  ECX == MethodTable
 LEAF_ENTRY RhpNewFinalizable, _TEXT
-
         mov         edx, GC_ALLOC_FINALIZE                          // Flags
         jmp         RhpNewObject
-
 LEAF_END RhpNewFinalizable, _TEXT
 
+// Allocate non-array object with finalizer on an 8 byte boundary.
+//  ECX == MethodTable
+LEAF_ENTRY RhpNewFinalizableAlign8, _TEXT
+        mov         edx, GC_ALLOC_FINALIZE + GC_ALLOC_ALIGN8        // Flags
+        jmp         RhpNewObject
+LEAF_END RhpNewFinalizableAlign8, _TEXT
+
 // Allocate non-array object
 //  ECX == MethodTable
 //  EDX == alloc flags
@@ -253,21 +306,14 @@ LEAF_ENTRY RhpNewObjectArrayFast, _TEXT
 LEAF_END RhpNewObjectArrayFast, _TEXT
 #endif
 
-
-//
-// Object* RhpNewArray(MethodTable *pMT, INT_PTR size)
-//
-// ecx == MethodTable
-// edx == element count
-//
-LEAF_ENTRY RhpNewArray, _TEXT
-
+// Shared code for RhpNewArray and RhpNewArrayFastAlign8
+.macro NEW_ARRAY Flags
         PUSH_COOP_PINVOKE_FRAME eax
 
         // Push alloc helper arguments (transition frame, size, flags, MethodTable).
         push        eax                                             // transition frame
         push        edx                                             // numElements
-        push        0                                               // Flags
+        push        \Flags                                          // Flags
         push        ecx                                             // MethodTable
 
         // void* RhpGcAlloc(MethodTable *pEEType, uint32_t uFlags, uintptr_t numElements, void * pTransitionFrame)
@@ -278,15 +324,37 @@ LEAF_ENTRY RhpNewArray, _TEXT
         POP_COOP_PINVOKE_FRAME
 
         test        eax, eax
-        jz          ArrayOutOfMemory
+        jz          1f
 
         ret
 
-ArrayOutOfMemory:
+1:
         // This is the OOM failure path. We're going to tail-call to a managed helper that will throw
         // an out of memory exception that the caller of this allocator understands.
 
         xor         edx, edx        // Indicate that we should throw OOM.
         jmp         RhExceptionHandling_FailedAllocation
+.endm
 
+//
+// Object* RhpNewArray(MethodTable *pMT, INT_PTR size)
+//
+// ecx == MethodTable
+// edx == element count
+//
+LEAF_ENTRY RhpNewArray, _TEXT
+        NEW_ARRAY 0
 LEAF_END RhpNewArray, _TEXT
+
+//
+// Object* RhpNewArrayFastAlign8(MethodTable *pMT, INT_PTR size)
+//
+// ecx == MethodTable
+// edx == element count
+//
+LEAF_ENTRY RhpNewArrayFastAlign8, _TEXT
+        // We don't really provide a fast path here. CoreCLR has a configurable threshold
+        // for array size to go to large object heap and it's not worth the extra effort
+        // to check for it.
+        NEW_ARRAY GC_ALLOC_ALIGN8
+LEAF_END RhpNewArrayFastAlign8, _TEXT