Update helper names across runtimes.

AaronRobinsonMSFT · AaronRobinsonMSFT · commit 5ad073f5084b · 2025-03-21T10:50:48.000-07:00
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Buffer.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Buffer.CoreCLR.cs
@@ -10,13 +10,13 @@ namespace System
     public partial class Buffer
     {
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Buffer_Clear")]
-        private static unsafe partial void __ZeroMemory(void* b, nuint byteLength);
+        private static unsafe partial void ZeroMemoryInternal(void* b, nuint byteLength);
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Buffer_MemMove")]
-        private static unsafe partial void __Memmove(byte* dest, byte* src, nuint len);
+        private static unsafe partial void MemmoveInternal(byte* dest, byte* src, nuint len);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void __BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount);
+        private static extern void BulkMoveWithWriteBarrierInternal(ref byte destination, ref byte source, nuint byteCount);
 
         // Used by ilmarshalers.cpp
         internal static unsafe void Memcpy(byte* dest, byte* src, int len)
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Buffer.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Buffer.NativeAot.cs
@@ -12,15 +12,15 @@ namespace System
     public static partial class Buffer
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe void __ZeroMemory(void* b, nuint byteLength) =>
+        private static unsafe void ZeroMemoryInternal(void* b, nuint byteLength) =>
             RuntimeImports.memset((byte*)b, 0, byteLength);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe void __Memmove(byte* dest, byte* src, nuint len) =>
+        private static unsafe void MemmoveInternal(byte* dest, byte* src, nuint len) =>
             RuntimeImports.memmove(dest, src, len);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void __BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount) =>
+        private static void BulkMoveWithWriteBarrierInternal(ref byte destination, ref byte source, nuint byteCount) =>
             RuntimeImports.RhBulkMoveWithWriteBarrier(ref destination, ref source, byteCount);
     }
 }
diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h
@@ -250,7 +250,7 @@ FCFuncStart(gArrayFuncs)
 FCFuncEnd()
 
 FCFuncStart(gBufferFuncs)
-    FCFuncElement("__BulkMoveWithWriteBarrier", Buffer::BulkMoveWithWriteBarrier)
+    FCFuncElement("BulkMoveWithWriteBarrierInternal", Buffer::BulkMoveWithWriteBarrier)
 FCFuncEnd()
 
 FCFuncStart(gGCFrameRegistration)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffer.cs b/src/libraries/System.Private.CoreLib/src/System/Buffer.cs
@@ -127,21 +127,21 @@ public static unsafe void MemoryCopy(void* source, void* destination, ulong dest
         // Non-inlinable wrapper around the QCall that avoids polluting the fast path
         // with P/Invoke prolog/epilog.
         [MethodImpl(MethodImplOptions.NoInlining)]
-        internal static unsafe void _Memmove(ref byte dest, ref byte src, nuint len)
+        internal static unsafe void Memmove(ref byte dest, ref byte src, nuint len)
         {
             fixed (byte* pDest = &dest)
             fixed (byte* pSrc = &src)
-                __Memmove(pDest, pSrc, len);
+                MemmoveInternal(pDest, pSrc, len);
         }
 
         // Non-inlinable wrapper around the QCall that avoids polluting the fast path
         // with P/Invoke prolog/epilog.
         [MethodImpl(MethodImplOptions.NoInlining)]
-        internal static unsafe void _ZeroMemory(ref byte b, nuint byteLength)
+        internal static unsafe void ZeroMemory(ref byte b, nuint byteLength)
         {
             fixed (byte* bytePointer = &b)
             {
-                __ZeroMemory(bytePointer, byteLength);
+                ZeroMemoryInternal(bytePointer, byteLength);
             }
         }
 
@@ -169,7 +169,7 @@ ref Unsafe.As<T, byte>(ref source),
             }
         }
 
-        // The maximum block size to for __BulkMoveWithWriteBarrier FCall. This is required to avoid GC starvation.
+        // The maximum block size to for BulkMoveWithWriteBarrierInternal FCall. This is required to avoid GC starvation.
 #if DEBUG // Stress the mechanism in debug builds
         private const uint BulkMoveWithWriteBarrierChunk = 0x400;
 #else
@@ -180,18 +180,18 @@ internal static void BulkMoveWithWriteBarrier(ref byte destination, ref byte sou
         {
             if (byteCount <= BulkMoveWithWriteBarrierChunk)
             {
-                __BulkMoveWithWriteBarrier(ref destination, ref source, byteCount);
+                BulkMoveWithWriteBarrierInternal(ref destination, ref source, byteCount);
                 Thread.FastPollGC();
             }
             else
             {
-                _BulkMoveWithWriteBarrier(ref destination, ref source, byteCount);
+                BulkMoveWithWriteBarrierBatch(ref destination, ref source, byteCount);
             }
         }
 
         // Non-inlinable wrapper around the loop for copying large blocks in chunks
         [MethodImpl(MethodImplOptions.NoInlining)]
-        private static void _BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount)
+        private static void BulkMoveWithWriteBarrierBatch(ref byte destination, ref byte source, nuint byteCount)
         {
             Debug.Assert(byteCount > BulkMoveWithWriteBarrierChunk);
 
@@ -205,7 +205,7 @@ private static void _BulkMoveWithWriteBarrier(ref byte destination, ref byte sou
                 do
                 {
                     byteCount -= BulkMoveWithWriteBarrierChunk;
-                    __BulkMoveWithWriteBarrier(ref destination, ref source, BulkMoveWithWriteBarrierChunk);
+                    BulkMoveWithWriteBarrierInternal(ref destination, ref source, BulkMoveWithWriteBarrierChunk);
                     Thread.FastPollGC();
                     destination = ref Unsafe.AddByteOffset(ref destination, BulkMoveWithWriteBarrierChunk);
                     source = ref Unsafe.AddByteOffset(ref source, BulkMoveWithWriteBarrierChunk);
@@ -218,12 +218,12 @@ private static void _BulkMoveWithWriteBarrier(ref byte destination, ref byte sou
                 do
                 {
                     byteCount -= BulkMoveWithWriteBarrierChunk;
-                    __BulkMoveWithWriteBarrier(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), BulkMoveWithWriteBarrierChunk);
+                    BulkMoveWithWriteBarrierInternal(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), BulkMoveWithWriteBarrierChunk);
                     Thread.FastPollGC();
                 }
                 while (byteCount > BulkMoveWithWriteBarrierChunk);
             }
-            __BulkMoveWithWriteBarrier(ref destination, ref source, byteCount);
+            BulkMoveWithWriteBarrierInternal(ref destination, ref source, byteCount);
             Thread.FastPollGC();
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.ByteMemOps.cs b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.ByteMemOps.cs
@@ -239,7 +239,7 @@ internal static void Memmove(ref byte dest, ref byte src, nuint len)
             Debug.Assert(len > 0);
             _ = Unsafe.ReadUnaligned<byte>(ref dest);
             _ = Unsafe.ReadUnaligned<byte>(ref src);
-            Buffer._Memmove(ref dest, ref src, len);
+            Buffer.Memmove(ref dest, ref src, len);
         }
 
         [Intrinsic] // Unrolled for small sizes
@@ -425,7 +425,7 @@ public static void ClearWithoutReferences(ref byte dest, nuint len)
         PInvoke:
             // Implicit nullchecks
             _ = Unsafe.ReadUnaligned<byte>(ref dest);
-            Buffer._ZeroMemory(ref dest, len);
+            Buffer.ZeroMemory(ref dest, len);
         }
 
         internal static void Fill(ref byte dest, byte value, nuint len)
diff --git a/src/mono/System.Private.CoreLib/src/System/Buffer.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Buffer.Mono.cs
@@ -8,10 +8,10 @@ namespace System
     public partial class Buffer
     {
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern unsafe void __ZeroMemory(void* b, nuint byteLength);
+        private static extern unsafe void ZeroMemoryInternal(void* b, nuint byteLength);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern unsafe void __Memmove(byte* dest, byte* src, nuint len);
+        private static extern unsafe void MemmoveInternal(byte* dest, byte* src, nuint len);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void BulkMoveWithWriteBarrier(ref byte dmem, ref byte smem, nuint len, IntPtr type_handle);
diff --git a/src/mono/mono/metadata/icall-def.h b/src/mono/mono/metadata/icall-def.h
@@ -140,8 +140,8 @@ HANDLES(ARRAY_14, "SetValueRelaxedImpl",  ves_icall_System_Array_SetValueRelaxed
 
 ICALL_TYPE(BUFFER, "System.Buffer", BUFFER_0)
 NOHANDLES(ICALL(BUFFER_0, "BulkMoveWithWriteBarrier", ves_icall_System_Buffer_BulkMoveWithWriteBarrier))
-NOHANDLES(ICALL(BUFFER_2, "__Memmove", ves_icall_System_Runtime_RuntimeImports_Memmove))
-NOHANDLES(ICALL(BUFFER_3, "__ZeroMemory", ves_icall_System_Runtime_RuntimeImports_ZeroMemory))
+NOHANDLES(ICALL(BUFFER_2, "MemmoveInternal", ves_icall_System_Runtime_RuntimeImports_Memmove))
+NOHANDLES(ICALL(BUFFER_3, "ZeroMemoryInternal", ves_icall_System_Runtime_RuntimeImports_ZeroMemory))
 
 ICALL_TYPE(DELEGATE, "System.Delegate", DELEGATE_1)
 HANDLES(DELEGATE_1, "AllocDelegateLike_internal", ves_icall_System_Delegate_AllocDelegateLike_internal, MonoMulticastDelegate, 1, (MonoDelegate))

Original file line number	Diff line number	Diff line change
`@@ -12,15 +12,15 @@ namespace System`
`12`	`12`	`public static partial class Buffer`
`13`	`13`	`{`
`14`	`14`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`15`		`- private static unsafe void __ZeroMemory(void* b, nuint byteLength) =>`
	`15`	`+ private static unsafe void ZeroMemoryInternal(void* b, nuint byteLength) =>`
`16`	`16`	`RuntimeImports.memset((byte*)b, 0, byteLength);`
`17`	`17`
`18`	`18`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`19`		`- private static unsafe void __Memmove(byte* dest, byte* src, nuint len) =>`
	`19`	`+ private static unsafe void MemmoveInternal(byte* dest, byte* src, nuint len) =>`
`20`	`20`	`RuntimeImports.memmove(dest, src, len);`
`21`	`21`
`22`	`22`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`23`		`- private static void __BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount) =>`
	`23`	`+ private static void BulkMoveWithWriteBarrierInternal(ref byte destination, ref byte source, nuint byteCount) =>`
`24`	`24`	`RuntimeImports.RhBulkMoveWithWriteBarrier(ref destination, ref source, byteCount);`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -127,21 +127,21 @@ public static unsafe void MemoryCopy(void* source, void* destination, ulong dest`
`127`	`127`	`// Non-inlinable wrapper around the QCall that avoids polluting the fast path`
`128`	`128`	`// with P/Invoke prolog/epilog.`
`129`	`129`	`[MethodImpl(MethodImplOptions.NoInlining)]`
`130`		`- internal static unsafe void _Memmove(ref byte dest, ref byte src, nuint len)`
	`130`	`+ internal static unsafe void Memmove(ref byte dest, ref byte src, nuint len)`
`131`	`131`	`{`
`132`	`132`	`fixed (byte* pDest = &dest)`
`133`	`133`	`fixed (byte* pSrc = &src)`
`134`		`- __Memmove(pDest, pSrc, len);`
	`134`	`+ MemmoveInternal(pDest, pSrc, len);`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`// Non-inlinable wrapper around the QCall that avoids polluting the fast path`
`138`	`138`	`// with P/Invoke prolog/epilog.`
`139`	`139`	`[MethodImpl(MethodImplOptions.NoInlining)]`
`140`		`- internal static unsafe void _ZeroMemory(ref byte b, nuint byteLength)`
	`140`	`+ internal static unsafe void ZeroMemory(ref byte b, nuint byteLength)`
`141`	`141`	`{`
`142`	`142`	`fixed (byte* bytePointer = &b)`
`143`	`143`	`{`
`144`		`- __ZeroMemory(bytePointer, byteLength);`
	`144`	`+ ZeroMemoryInternal(bytePointer, byteLength);`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`
`@@ -169,7 +169,7 @@ ref Unsafe.As<T, byte>(ref source),`
`169`	`169`	`}`
`170`	`170`	`}`
`171`	`171`
`172`		`- // The maximum block size to for __BulkMoveWithWriteBarrier FCall. This is required to avoid GC starvation.`
	`172`	`+ // The maximum block size to for BulkMoveWithWriteBarrierInternal FCall. This is required to avoid GC starvation.`
`173`	`173`	`#if DEBUG // Stress the mechanism in debug builds`
`174`	`174`	`private const uint BulkMoveWithWriteBarrierChunk = 0x400;`
`175`	`175`	`#else`
`@@ -180,18 +180,18 @@ internal static void BulkMoveWithWriteBarrier(ref byte destination, ref byte sou`
`180`	`180`	`{`
`181`	`181`	`if (byteCount <= BulkMoveWithWriteBarrierChunk)`
`182`	`182`	`{`
`183`		`- __BulkMoveWithWriteBarrier(ref destination, ref source, byteCount);`
	`183`	`+ BulkMoveWithWriteBarrierInternal(ref destination, ref source, byteCount);`
`184`	`184`	`Thread.FastPollGC();`
`185`	`185`	`}`
`186`	`186`	`else`
`187`	`187`	`{`
`188`		`- _BulkMoveWithWriteBarrier(ref destination, ref source, byteCount);`
	`188`	`+ BulkMoveWithWriteBarrierBatch(ref destination, ref source, byteCount);`
`189`	`189`	`}`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`// Non-inlinable wrapper around the loop for copying large blocks in chunks`
`193`	`193`	`[MethodImpl(MethodImplOptions.NoInlining)]`
`194`		`- private static void _BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount)`
	`194`	`+ private static void BulkMoveWithWriteBarrierBatch(ref byte destination, ref byte source, nuint byteCount)`
`195`	`195`	`{`
`196`	`196`	`Debug.Assert(byteCount > BulkMoveWithWriteBarrierChunk);`
`197`	`197`
`@@ -205,7 +205,7 @@ private static void _BulkMoveWithWriteBarrier(ref byte destination, ref byte sou`
`205`	`205`	`do`
`206`	`206`	`{`
`207`	`207`	`byteCount -= BulkMoveWithWriteBarrierChunk;`
`208`		`- __BulkMoveWithWriteBarrier(ref destination, ref source, BulkMoveWithWriteBarrierChunk);`
	`208`	`+ BulkMoveWithWriteBarrierInternal(ref destination, ref source, BulkMoveWithWriteBarrierChunk);`
`209`	`209`	`Thread.FastPollGC();`
`210`	`210`	`destination = ref Unsafe.AddByteOffset(ref destination, BulkMoveWithWriteBarrierChunk);`
`211`	`211`	`source = ref Unsafe.AddByteOffset(ref source, BulkMoveWithWriteBarrierChunk);`
`@@ -218,12 +218,12 @@ private static void _BulkMoveWithWriteBarrier(ref byte destination, ref byte sou`
`218`	`218`	`do`
`219`	`219`	`{`
`220`	`220`	`byteCount -= BulkMoveWithWriteBarrierChunk;`
`221`		`- __BulkMoveWithWriteBarrier(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), BulkMoveWithWriteBarrierChunk);`
	`221`	`+ BulkMoveWithWriteBarrierInternal(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), BulkMoveWithWriteBarrierChunk);`
`222`	`222`	`Thread.FastPollGC();`
`223`	`223`	`}`
`224`	`224`	`while (byteCount > BulkMoveWithWriteBarrierChunk);`
`225`	`225`	`}`
`226`		`- __BulkMoveWithWriteBarrier(ref destination, ref source, byteCount);`
	`226`	`+ BulkMoveWithWriteBarrierInternal(ref destination, ref source, byteCount);`
`227`	`227`	`Thread.FastPollGC();`
`228`	`228`	`}`
`229`	`229`