Rewrite Buffer.BlockCopy in C#

src/System.Private.CoreLib/shared/System/Buffer.cs

@@ -26,6 +26,54 @@ namespace System
 {
     public static partial class Buffer
     {
+        // Copies from one primitive array to another primitive array without
+        // respecting types.  This calls memmove internally.  The count and
+        // offset parameters here are in bytes.  If you want to use traditional
+        // array element indices and counts, use Array.Copy.
+        public static unsafe void BlockCopy(Array src, int srcOffset, Array dst, int dstOffset, int count)
+        {
+            if (src == null)
+                throw new ArgumentNullException(nameof(src));
+            if (dst == null)
+                throw new ArgumentNullException(nameof(dst));
+
+            nuint uSrcLen = (nuint)src.LongLength;
+            if (src.GetType() != typeof(byte[]))
+            {
+                if (!IsPrimitiveTypeArray(src))
+                    throw new ArgumentException(SR.Arg_MustBePrimArray, nameof(src));
+                uSrcLen *= (nuint)src.GetElementSize();
+            }
+
+            nuint uDstLen = uSrcLen;
+            if (src != dst)
+            {
+                uDstLen = (nuint)dst.LongLength;
+                if (dst.GetType() != typeof(byte[]))
+                {
+                    if (!IsPrimitiveTypeArray(dst))
+                        throw new ArgumentException(SR.Arg_MustBePrimArray, nameof(dst));
+                    uDstLen *= (nuint)dst.GetElementSize();
+                }
+            }
+
+            if (srcOffset < 0)
+                throw new ArgumentOutOfRangeException(nameof(srcOffset), SR.ArgumentOutOfRange_MustBeNonNegInt32);
+            if (dstOffset < 0)
+                throw new ArgumentOutOfRangeException(nameof(dstOffset), SR.ArgumentOutOfRange_MustBeNonNegInt32);
+            if (count < 0)
+                throw new ArgumentOutOfRangeException(nameof(count), SR.ArgumentOutOfRange_MustBeNonNegInt32);
+
+            nuint uCount = (nuint)count;
+            nuint uSrcOffset = (nuint)srcOffset;
+            nuint uDstOffset = (nuint)dstOffset;
+
+            if ((uSrcLen < uSrcOffset + uCount) || (uDstLen < uDstOffset + uCount))
+                throw new ArgumentException(SR.Argument_InvalidOffLen);
+
+            Memmove(ref Unsafe.AddByteOffset(ref dst.GetRawArrayData(), uDstOffset), ref Unsafe.AddByteOffset(ref src.GetRawArrayData(), uSrcOffset), uCount);
+        }
+
         public static int ByteLength(Array array)
         {
             // Is the array present?

src/System.Private.CoreLib/src/System/Array.CoreCLR.cs

@@ -357,9 +357,6 @@ public extern int Rank
         [MethodImpl(MethodImplOptions.InternalCall)]
         public extern int GetLowerBound(int dimension);
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern ref byte GetRawArrayData();
-
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern bool TrySZBinarySearch(Array sourceArray, int sourceIndex, int count, object? value, out int retVal);
 

src/System.Private.CoreLib/src/System/Buffer.CoreCLR.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using Internal.Runtime.CompilerServices;
 
 #pragma warning disable SA1121 // explicitly using type aliases instead of built-in types
 #if BIT64
@@ -17,14 +18,6 @@ namespace System
 {
     public partial class Buffer
     {
-        // Copies from one primitive array to another primitive array without
-        // respecting types.  This calls memmove internally.  The count and
-        // offset parameters here are in bytes.  If you want to use traditional
-        // array element indices and counts, use Array.Copy.
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        public static extern void BlockCopy(Array src, int srcOffset,
-            Array dst, int dstOffset, int count);
-
         // Returns a bool to indicate if the array is of primitive data types
         // or not.
         [MethodImpl(MethodImplOptions.InternalCall)]

src/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs

@@ -7,6 +7,13 @@
 using System.Runtime.InteropServices;
 using Internal.Runtime.CompilerServices;
 
+#pragma warning disable SA1121 // explicitly using type aliases instead of built-in types
+#if BIT64
+using nuint = System.UInt64;
+#else
+using nuint = System.UInt32;
+#endif
+
 namespace System.Runtime.CompilerServices
 {
     public static partial class RuntimeHelpers
@@ -164,12 +171,14 @@ internal static ref byte GetRawData(this object obj) =>
         internal static ref byte GetRawSzArrayData(this Array array) =>
             ref Unsafe.As<RawArrayData>(array).Data;
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe ref byte GetRawArrayData(this Array array) =>
+            ref Unsafe.AddByteOffset(ref Unsafe.As<RawData>(array).Data, (nuint)GetObjectMethodTablePointer(array)->BaseSize - (nuint)(2 * sizeof(IntPtr)));
+
         internal static unsafe ushort GetElementSize(this Array array)
         {
             Debug.Assert(ObjectHasComponentSize(array));
-
-            // The first UINT16 of the method table is component size.
-            return *(ushort*)GetObjectMethodTablePointer(array);
+            return GetObjectMethodTablePointer(array)->ComponentSize;
         }
 
         // Returns true iff the object has a component size;
@@ -181,28 +190,38 @@ internal static unsafe bool ObjectHasComponentSize(object obj)
             // [ pMethodTable || .. object data .. ]
             //   ^-- the object reference points here
             //
-            // The first DWORD of the method table class will have its high bit set if the
+            // The m_dwFlags field of the method table class will have its high bit set if the
             // method table has component size info stored somewhere. See member
             // MethodTable:IsStringOrArray in src\vm\methodtable.h for full details.
             //
             // So in effect this method is the equivalent of
             // return ((MethodTable*)(*obj))->IsStringOrArray();
+            return (int)GetObjectMethodTablePointer(obj)->Flags < 0;
+        }
 
-            Debug.Assert(obj != null);
-            return *(int*)GetObjectMethodTablePointer(obj) < 0;
+        // Subset of src\vm\methodtable.h
+        [StructLayout(LayoutKind.Explicit)]
+        private struct MethodTable
+        {
+            [FieldOffset(0)]
+            public ushort ComponentSize;
+            [FieldOffset(0)]
+            public uint Flags;
+            [FieldOffset(4)]
+            public uint BaseSize;
         }
 
         // Given an object reference, returns its MethodTable* as an IntPtr.
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static IntPtr GetObjectMethodTablePointer(object obj)
+        private static unsafe MethodTable* GetObjectMethodTablePointer(object obj)
         {
             Debug.Assert(obj != null);
 
             // We know that the first data field in any managed object is immediately after the
             // method table pointer, so just back up one pointer and immediately deref.
             // This is not ideal in terms of minimizing instruction count but is the best we can do at the moment.
 
-            return Unsafe.Add(ref Unsafe.As<byte, IntPtr>(ref obj.GetRawData()), -1);
+            return (MethodTable *)Unsafe.Add(ref Unsafe.As<byte, IntPtr>(ref obj.GetRawData()), -1);
 
             // The JIT currently implements this as:
             // lea tmp, [rax + 8h] ; assume rax contains the object reference, tmp is type IntPtr&

src/inc/dacvars.h

@@ -187,7 +187,6 @@ DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pEnumClass, ::g_pEnumClass)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pThreadClass, ::g_pThreadClass)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pPredefinedArrayTypes, ::g_pPredefinedArrayTypes)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_TypedReferenceMT, ::g_TypedReferenceMT)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pByteArrayMT, ::g_pByteArrayMT)
 
 #ifdef FEATURE_COMINTEROP
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pBaseCOMObject, ::g_pBaseCOMObject)

src/inc/jithelpers.h

@@ -146,17 +146,16 @@
     JITHELPER(CORINFO_HELP_GETSYNCFROMCLASSHANDLE,  JIT_GetSyncFromClassHandle, CORINFO_HELP_SIG_REG_ONLY)
 
     // Security callout support 
-    JITHELPER(CORINFO_HELP_SECURITY_PROLOG,         JIT_Security_Prolog,CORINFO_HELP_SIG_REG_ONLY)
-    JITHELPER(CORINFO_HELP_SECURITY_PROLOG_FRAMED,  JIT_Security_Prolog_Framed,CORINFO_HELP_SIG_REG_ONLY)
+    JITHELPER(CORINFO_HELP_SECURITY_PROLOG,         NULL,CORINFO_HELP_SIG_REG_ONLY)
+    JITHELPER(CORINFO_HELP_SECURITY_PROLOG_FRAMED,  NULL,CORINFO_HELP_SIG_REG_ONLY)
 
-    JITHELPER(CORINFO_HELP_METHOD_ACCESS_CHECK,     JIT_MethodAccessCheck,CORINFO_HELP_SIG_8_STACK)
-    JITHELPER(CORINFO_HELP_FIELD_ACCESS_CHECK,      JIT_FieldAccessCheck,CORINFO_HELP_SIG_4_STACK)
-    JITHELPER(CORINFO_HELP_CLASS_ACCESS_CHECK,      JIT_ClassAccessCheck,CORINFO_HELP_SIG_4_STACK)
+    JITHELPER(CORINFO_HELP_METHOD_ACCESS_CHECK,     NULL,CORINFO_HELP_SIG_8_STACK)
+    JITHELPER(CORINFO_HELP_FIELD_ACCESS_CHECK,      NULL,CORINFO_HELP_SIG_4_STACK)
+    JITHELPER(CORINFO_HELP_CLASS_ACCESS_CHECK,      NULL,CORINFO_HELP_SIG_4_STACK)
 
-    JITHELPER(CORINFO_HELP_DELEGATE_SECURITY_CHECK, JIT_DelegateSecurityCheck,CORINFO_HELP_SIG_REG_ONLY)
+    JITHELPER(CORINFO_HELP_DELEGATE_SECURITY_CHECK, NULL,CORINFO_HELP_SIG_REG_ONLY)
 
-     // Verification runtime callout support 
-    JITHELPER(CORINFO_HELP_VERIFICATION_RUNTIME_CHECK, JIT_VerificationRuntimeCheck,CORINFO_HELP_SIG_REG_ONLY)
+    JITHELPER(CORINFO_HELP_VERIFICATION_RUNTIME_CHECK, NULL,CORINFO_HELP_SIG_REG_ONLY)
 
     // GC support
     DYNAMICJITHELPER(CORINFO_HELP_STOP_FOR_GC,  JIT_RareDisableHelper,  CORINFO_HELP_SIG_REG_ONLY)

src/jit/gentree.cpp

@@ -12340,7 +12340,7 @@ GenTree* Compiler::gtFoldTypeCompare(GenTree* tree)
         }
 
         // We can't answer the equality comparison definitively at jit
-        // time, but can still simplfy the comparison.
+        // time, but can still simplify the comparison.
         //
         // Find out how we can compare the two handles.
         // NOTE: We're potentially passing NO_CLASS_HANDLE, but the runtime knows what to do with it here.

src/vm/appdomain.cpp

@@ -2083,10 +2083,6 @@ void SystemDomain::LoadBaseSystemClasses()
     g_pUtf8StringClass = MscorlibBinder::GetClass(CLASS__UTF8_STRING);
 #endif // FEATURE_UTF8STRING
 
-    // Used by Buffer::BlockCopy
-    g_pByteArrayMT = ClassLoader::LoadArrayTypeThrowing(
-        TypeHandle(MscorlibBinder::GetElementType(ELEMENT_TYPE_U1))).AsArray()->GetMethodTable();
-
 #ifndef CROSSGEN_COMPILE
     CrossLoaderAllocatorHashSetup::EnsureTypesLoaded();
 #endif

src/vm/comutilnative.cpp

@@ -685,90 +685,6 @@ void QCALLTYPE ExceptionNative::GetMessageFromNativeResources(ExceptionMessageKi
     END_QCALL;
 }
 
-// BlockCopy
-// This method from one primitive array to another based
-//  upon an offset into each an a byte count.
-FCIMPL5(VOID, Buffer::BlockCopy, ArrayBase *src, int srcOffset, ArrayBase *dst, int dstOffset, int count)
-{
-    FCALL_CONTRACT;
-
-    // Verify that both the src and dst are Arrays of primitive
-    //  types.
-    // <TODO>@TODO: We need to check for booleans</TODO>
-    if (src==NULL || dst==NULL)
-        FCThrowArgumentNullVoid((src==NULL) ? W("src") : W("dst"));
-
-    SIZE_T srcLen, dstLen;
-
-    //
-    // Use specialized fast path for byte arrays because of it is what Buffer::BlockCopy is 
-    // typically used for.
-    //
-
-    MethodTable * pByteArrayMT = g_pByteArrayMT;
-    _ASSERTE(pByteArrayMT != NULL);
-
-    // Optimization: If src is a byte array, we can
-    // simply set srcLen to GetNumComponents, without having
-    // to call GetComponentSize or verifying GetArrayElementType
-    if (src->GetMethodTable() == pByteArrayMT)
-    {
-        srcLen = src->GetNumComponents();
-    }
-    else
-    {
-        srcLen = src->GetNumComponents() * src->GetComponentSize();
-
-        // We only want to allow arrays of primitives, no Objects.
-        const CorElementType srcET = src->GetArrayElementType();
-        if (!CorTypeInfo::IsPrimitiveType_NoThrow(srcET))
-            FCThrowArgumentVoid(W("src"), W("Arg_MustBePrimArray"));
-    }
-
-    // Optimization: If copying to/from the same array, then
-    // we know that dstLen and srcLen must be the same.
-    if (src == dst)
-    {
-        dstLen = srcLen;
-    }
-    else if (dst->GetMethodTable() == pByteArrayMT)
-    {
-        dstLen = dst->GetNumComponents();
-    }
-    else
-    {
-        dstLen = dst->GetNumComponents() * dst->GetComponentSize();
-        if (dst->GetMethodTable() != src->GetMethodTable())
-        {
-            const CorElementType dstET = dst->GetArrayElementType();
-            if (!CorTypeInfo::IsPrimitiveType_NoThrow(dstET))
-                FCThrowArgumentVoid(W("dst"), W("Arg_MustBePrimArray"));
-        }
-    }
-
-    if (srcOffset < 0 || dstOffset < 0 || count < 0) {
-        const WCHAR* str = W("srcOffset");
-        if (dstOffset < 0) str = W("dstOffset");
-        if (count < 0) str = W("count");
-        FCThrowArgumentOutOfRangeVoid(str, W("ArgumentOutOfRange_NeedNonNegNum"));
-    }
-
-    if (srcLen < (SIZE_T)srcOffset + (SIZE_T)count || dstLen < (SIZE_T)dstOffset + (SIZE_T)count) {
-        FCThrowArgumentVoid(NULL, W("Argument_InvalidOffLen"));
-    }
-
-    PTR_BYTE srcPtr = src->GetDataPtr() + srcOffset;
-    PTR_BYTE dstPtr = dst->GetDataPtr() + dstOffset;
-
-    if ((srcPtr != dstPtr) && (count > 0)) {
-        memmove(dstPtr, srcPtr, count);
-    }
-
-    FC_GC_POLL();
-}
-FCIMPLEND
-
-
 void QCALLTYPE MemoryNative::Clear(void *dst, size_t length)
 {
     QCALL_CONTRACT;

src/vm/comutilnative.h

@@ -80,7 +80,6 @@ class Buffer {
     // BlockCopy
     // This method from one primitive array to another based
     //      upon an offset into each an a byte count.
-    static FCDECL5(VOID, BlockCopy, ArrayBase *src, int srcOffset, ArrayBase *dst, int dstOffset, int count);
     static FCDECL1(FC_BOOL_RET, IsPrimitiveTypeArray, ArrayBase *arrayUNSAFE);
 
     static void QCALLTYPE MemMove(void *dst, void *src, size_t length);

src/vm/ecalllist.h

@@ -739,7 +739,6 @@ FCFuncStart(gArrayFuncs)
 FCFuncEnd()
 
 FCFuncStart(gBufferFuncs)
-    FCFuncElement("BlockCopy", Buffer::BlockCopy)
     FCFuncElement("IsPrimitiveTypeArray", Buffer::IsPrimitiveTypeArray)
 #ifdef _TARGET_ARM_
     FCFuncElement("Memcpy", FCallMemcpy)

src/vm/ilmarshalers.cpp

@@ -3444,7 +3444,7 @@ void ILArrayWithOffsetMarshaler::EmitConvertSpaceAndContentsCLRToNativeTemp(ILCo
     EmitLoadNativeValue(pslILEmit);                 // dest
 
     pslILEmit->EmitLDLOC(m_dwPinnedLocalNum);
-    pslILEmit->EmitCALL(METHOD__ARRAY__GET_RAW_ARRAY_DATA, 1, 1);
+    pslILEmit->EmitCALL(METHOD__RUNTIME_HELPERS__GET_RAW_ARRAY_DATA, 1, 1);
     pslILEmit->EmitCONV_I();
 
     EmitLoadManagedValue(pslILEmit);
@@ -3488,7 +3488,7 @@ void ILArrayWithOffsetMarshaler::EmitConvertContentsNativeToCLR(ILCodeStream* ps
     pslILEmit->EmitSTLOC(m_dwPinnedLocalNum);
 
     pslILEmit->EmitLDLOC(m_dwPinnedLocalNum);
-    pslILEmit->EmitCALL(METHOD__ARRAY__GET_RAW_ARRAY_DATA, 1, 1);
+    pslILEmit->EmitCALL(METHOD__RUNTIME_HELPERS__GET_RAW_ARRAY_DATA, 1, 1);
     pslILEmit->EmitCONV_I();
 
     pslILEmit->EmitLDLOC(m_dwOffsetLocalNum);