ARM64: avoid memory barrier in InlinedMemmoveGCRefsHelper if dest is not on heap

src/coreclr/classlibnative/bcltype/arraynative.inl

@@ -307,7 +307,12 @@ FORCEINLINE void InlinedMemmoveGCRefsHelper(void *dest, const void *src, size_t
     _ASSERTE(CheckPointer(dest));
     _ASSERTE(CheckPointer(src));
 
-    GCHeapMemoryBarrier();
+    const bool notInHeap = ((BYTE*)dest < g_lowest_address || (BYTE*)dest >= g_highest_address);
+
+    if (!notInHeap)
+    {
+        GCHeapMemoryBarrier();
+    }
 
     // To be able to copy forwards, the destination buffer cannot start inside the source buffer
     if ((size_t)dest - (size_t)src >= len)
@@ -319,7 +324,10 @@ FORCEINLINE void InlinedMemmoveGCRefsHelper(void *dest, const void *src, size_t
         InlinedBackwardGCSafeCopyHelper(dest, src, len);
     }
 
-    InlinedSetCardsAfterBulkCopyHelper((Object**)dest, len);
+    if (!notInHeap)
+    {
+        InlinedSetCardsAfterBulkCopyHelper((Object**)dest, len);
+    }
 }
 
 #endif // !_ARRAYNATIVE_INL_

src/coreclr/vm/gchelpers.cpp

@@ -1484,39 +1484,4 @@ void ErectWriteBarrierForMT(MethodTable **dst, MethodTable *ref)
             }
         }
     }
-}
-
-//----------------------------------------------------------------------------
-//
-// Write Barrier Support for bulk copy ("Clone") operations
-//
-// StartPoint is the target bulk copy start point
-// len is the length of the bulk copy (in bytes)
-//
-//
-// Performance Note:
-//
-// This is implemented somewhat "conservatively", that is we
-// assume that all the contents of the bulk copy are object
-// references.  If they are not, and the value lies in the
-// ephemeral range, we will set false positives in the card table.
-//
-// We could use the pointer maps and do this more accurately if necessary
-
-#if defined(_MSC_VER) && defined(TARGET_X86)
-#pragma optimize("y", on)        // Small critical routines, don't put in EBP frame
-#endif //_MSC_VER && TARGET_X86
-
-void
-SetCardsAfterBulkCopy(Object **start, size_t len)
-{
-    // If the size is smaller than a pointer, no write barrier is required.
-    if (len >= sizeof(uintptr_t))
-    {
-        InlinedSetCardsAfterBulkCopyHelper(start, len);
-    }
-}
-
-#if defined(_MSC_VER) && defined(TARGET_X86)
-#pragma optimize("", on)        // Go back to command line default optimizations
-#endif //_MSC_VER && TARGET_X86
+}

src/coreclr/vm/gchelpers.h

@@ -87,7 +87,6 @@ extern void ThrowOutOfMemoryDimensionsExceeded();
 //========================================================================
 
 void ErectWriteBarrier(OBJECTREF* dst, OBJECTREF ref);
-void SetCardsAfterBulkCopy(Object **start, size_t len);
 
 void PublishFrozenObject(Object*& orObject);
 

src/coreclr/vm/gchelpers.inl

@@ -31,13 +31,12 @@
 
 FORCEINLINE void InlinedSetCardsAfterBulkCopyHelper(Object **start, size_t len)
 {
+    // Caller is expected to check whether start points into the heap or not
+    _ASSERTE(!((BYTE*)start < g_lowest_address || (BYTE*)start >= g_highest_address));
+
     // Check whether the writes were even into the heap. If not there's no card update required.
     // Also if the size is smaller than a pointer, no write barrier is required.
     _ASSERTE(len >= sizeof(uintptr_t));
-    if ((BYTE*)start < g_lowest_address || (BYTE*)start >= g_highest_address)
-    {
-        return;
-    }
 
     // Don't optimize the Generation 0 case if we are checking for write barrier violations
     // since we need to update the shadow heap even in the generation 0 case.