Remove some RuntimeExport/RuntimeImport indirections (#110437)

MichalStrehovsky · web-flow · commit b085dadd1600 · 2024-12-09T08:46:46.000+01:00
We had indirections set up where we'd `RuntimeExport` a method under a symbolic name and then `RuntimeImport` it elsewhere (or call the export from JIT-generated code). Most of this was motivated by the old Redhawk layering where things like casting and interface dispatch were part of Runtime.Base and not part of CoreLib. Since we decided if we ever reintroduce a Runtime.Base, we wouldn't have casting in it, this indirection will no longer be needed. Motivated by #110267 (and also the reason why I'm only doing it for `RuntimeExport`s used from the JIT right now). Once that PR gets in, calling methods through `RuntimeExport`s would actually become a bigger deoptimization than it is now.
diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/CompilerServices/Unsafe.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/CompilerServices/Unsafe.cs
@@ -16,6 +16,21 @@ namespace System.Runtime.CompilerServices
     /// </summary>
     public static unsafe class Unsafe
     {
+        /// <summary>
+        /// Determines the byte offset from origin to target from the given references.
+        /// </summary>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static IntPtr ByteOffset<T>(ref readonly T origin, ref readonly T target)
+        {
+            throw new PlatformNotSupportedException();
+
+            // ldarg .1
+            // ldarg .0
+            // sub
+            // ret
+        }
+
         /// <summary>
         /// Returns a pointer to the given by-ref parameter.
         /// </summary>
diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/RuntimeExports.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/RuntimeExports.cs
@@ -73,7 +73,6 @@ public static unsafe object RhNewArray(MethodTable* pEEType, int length)
             }
         }
 
-        [RuntimeExport("RhBox")]
         public static unsafe object RhBox(MethodTable* pEEType, ref byte data)
         {
             // A null can be passed for boxing of a null ref.
@@ -207,7 +206,6 @@ public static unsafe void RhUnboxAny(object? o, ref byte data, MethodTable* pUnb
         //
         // Unbox helpers with RyuJIT conventions
         //
-        [RuntimeExport("RhUnbox2")]
         public static unsafe ref byte RhUnbox2(MethodTable* pUnboxToEEType, object obj)
         {
             if ((obj == null) || !UnboxAnyTypeCompare(obj.GetMethodTable(), pUnboxToEEType))
@@ -218,7 +216,6 @@ public static unsafe ref byte RhUnbox2(MethodTable* pUnboxToEEType, object obj)
             return ref obj.GetRawData();
         }
 
-        [RuntimeExport("RhUnboxNullable")]
         public static unsafe void RhUnboxNullable(ref byte data, MethodTable* pUnboxToEEType, object obj)
         {
             if (obj != null && obj.GetMethodTable() != pUnboxToEEType->NullableType)
@@ -228,7 +225,6 @@ public static unsafe void RhUnboxNullable(ref byte data, MethodTable* pUnboxToEE
             RhUnbox(obj, ref data, pUnboxToEEType);
         }
 
-        [RuntimeExport("RhUnboxTypeTest")]
         public static unsafe void RhUnboxTypeTest(MethodTable* pType, MethodTable* pBoxType)
         {
             Debug.Assert(pType->IsValueType);
diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs
@@ -63,7 +63,6 @@ internal enum AssignmentVariation
         // IsInstanceOf test used for unusual cases (naked type parameters, variant generic types)
         // Unlike the IsInstanceOfInterface and IsInstanceOfClass functions,
         // this test must deal with all kinds of type tests
-        [RuntimeExport("RhTypeCast_IsInstanceOfAny")]
         public static unsafe object? IsInstanceOfAny(MethodTable* pTargetType, object? obj)
         {
             if (obj != null)
@@ -94,7 +93,6 @@ internal enum AssignmentVariation
             return IsInstanceOfAny_NoCacheLookup(pTargetType, obj);
         }
 
-        [RuntimeExport("RhTypeCast_IsInstanceOfInterface")]
         public static unsafe object? IsInstanceOfInterface(MethodTable* pTargetType, object? obj)
         {
             Debug.Assert(pTargetType->IsInterface);
@@ -184,7 +182,6 @@ internal enum AssignmentVariation
             return obj;
         }
 
-        [RuntimeExport("RhTypeCast_IsInstanceOfClass")]
         public static unsafe object? IsInstanceOfClass(MethodTable* pTargetType, object? obj)
         {
             Debug.Assert(!pTargetType->IsParameterizedType, "IsInstanceOfClass called with parameterized MethodTable");
@@ -248,7 +245,6 @@ internal enum AssignmentVariation
             return obj;
         }
 
-        [RuntimeExport("RhTypeCast_IsInstanceOfException")]
         public static unsafe bool IsInstanceOfException(MethodTable* pTargetType, object? obj)
         {
             // Based on IsInstanceOfClass
@@ -279,7 +275,6 @@ public static unsafe bool IsInstanceOfException(MethodTable* pTargetType, object
         // ChkCast test used for unusual cases (naked type parameters, variant generic types)
         // Unlike the ChkCastInterface and ChkCastClass functions,
         // this test must deal with all kinds of type tests
-        [RuntimeExport("RhTypeCast_CheckCastAny")]
         public static unsafe object CheckCastAny(MethodTable* pTargetType, object obj)
         {
             CastResult result;
@@ -307,7 +302,6 @@ public static unsafe object CheckCastAny(MethodTable* pTargetType, object obj)
             return objRet;
         }
 
-        [RuntimeExport("RhTypeCast_CheckCastInterface")]
         public static unsafe object CheckCastInterface(MethodTable* pTargetType, object obj)
         {
             Debug.Assert(pTargetType->IsInterface);
@@ -393,7 +387,6 @@ private static unsafe object CheckCastInterface_Helper(MethodTable* pTargetType,
             return ThrowInvalidCastException(pTargetType);
         }
 
-        [RuntimeExport("RhTypeCast_CheckCastClass")]
         public static unsafe object CheckCastClass(MethodTable* pTargetType, object obj)
         {
             Debug.Assert(!pTargetType->IsParameterizedType, "CheckCastClass called with parameterized MethodTable");
@@ -411,7 +404,6 @@ public static unsafe object CheckCastClass(MethodTable* pTargetType, object obj)
 
         // Optimized helper for classes. Assumes that the trivial cases
         // has been taken care of by the inlined check
-        [RuntimeExport("RhTypeCast_CheckCastClassSpecial")]
         private static unsafe object CheckCastClassSpecial(MethodTable* pTargetType, object obj)
         {
             Debug.Assert(!pTargetType->IsParameterizedType, "CheckCastClassSpecial called with parameterized MethodTable");
@@ -761,8 +753,6 @@ private static unsafe void ThrowArrayMismatchException(object?[] array)
         //
         // Array stelem/ldelema helpers with RyuJIT conventions
         //
-
-        [RuntimeExport("RhpLdelemaRef")]
         public static unsafe ref object? LdelemaRef(object?[] array, nint index, MethodTable* elementType)
         {
             Debug.Assert(array is null || array.GetMethodTable()->IsArray, "first argument must be an array");
@@ -794,7 +784,6 @@ private static unsafe void ThrowArrayMismatchException(object?[] array)
             return ref element;
         }
 
-        [RuntimeExport("RhpStelemRef")]
         public static unsafe void StelemRef(object?[] array, nint index, object? obj)
         {
             // This is supported only on arrays
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs
@@ -216,7 +216,7 @@ public static unsafe void StoreValueTypeField(IntPtr address, object fieldValue,
 
         public static unsafe object LoadValueTypeField(IntPtr address, RuntimeTypeHandle fieldType)
         {
-            return RuntimeImports.RhBox(fieldType.ToMethodTable(), ref *(byte*)address);
+            return RuntimeExports.RhBox(fieldType.ToMethodTable(), ref *(byte*)address);
         }
 
         public static unsafe object LoadPointerTypeField(IntPtr address, RuntimeTypeHandle fieldType)
@@ -236,15 +236,15 @@ public static unsafe void StoreValueTypeField(object obj, int fieldOffset, objec
         public static unsafe object LoadValueTypeField(object obj, int fieldOffset, RuntimeTypeHandle fieldType)
         {
             ref byte address = ref Unsafe.AddByteOffset(ref obj.GetRawData(), new IntPtr(fieldOffset - ObjectHeaderSize));
-            return RuntimeImports.RhBox(fieldType.ToMethodTable(), ref address);
+            return RuntimeExports.RhBox(fieldType.ToMethodTable(), ref address);
         }
 
         public static unsafe object LoadPointerTypeField(object obj, int fieldOffset, RuntimeTypeHandle fieldType)
         {
             ref byte address = ref Unsafe.AddByteOffset(ref obj.GetRawData(), new IntPtr(fieldOffset - ObjectHeaderSize));
 
             if (fieldType.ToMethodTable()->IsFunctionPointer)
-                return RuntimeImports.RhBox(MethodTable.Of<IntPtr>(), ref address);
+                return RuntimeExports.RhBox(MethodTable.Of<IntPtr>(), ref address);
 
             return ReflectionPointer.Box((void*)Unsafe.As<byte, IntPtr>(ref address), Type.GetTypeFromHandle(fieldType));
         }
@@ -285,7 +285,7 @@ public static object LoadValueTypeFieldValueFromValueType(TypedReference typedRe
             Debug.Assert(TypedReference.TargetTypeToken(typedReference).ToMethodTable()->IsValueType);
             Debug.Assert(fieldTypeHandle.ToMethodTable()->IsValueType);
 
-            return RuntimeImports.RhBox(fieldTypeHandle.ToMethodTable(), ref Unsafe.Add<byte>(ref typedReference.Value, fieldOffset));
+            return RuntimeExports.RhBox(fieldTypeHandle.ToMethodTable(), ref Unsafe.Add<byte>(ref typedReference.Value, fieldOffset));
         }
 
         [CLSCompliant(false)]
@@ -391,7 +391,7 @@ public static bool IsInterface(RuntimeTypeHandle type)
 
         public static unsafe object Box(RuntimeTypeHandle type, IntPtr address)
         {
-            return RuntimeImports.RhBox(type.ToMethodTable(), ref *(byte*)address);
+            return RuntimeExports.RhBox(type.ToMethodTable(), ref *(byte*)address);
         }
 
         //==============================================================================================
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Array.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Array.NativeAot.cs
@@ -330,7 +330,7 @@ private static unsafe void CopyImplGcRefArray(Array sourceArray, int sourceIndex
                 for (int i = 0; i < length; i++)
                 {
                     object? value = Unsafe.Add(ref refSourceArray, sourceIndex - i);
-                    if (mustCastCheckEachElement && value != null && RuntimeImports.IsInstanceOf(destinationElementEEType, value) == null)
+                    if (mustCastCheckEachElement && value != null && TypeCast.IsInstanceOfAny(destinationElementEEType, value) == null)
                         throw new InvalidCastException(SR.InvalidCast_DownCastArrayElement);
                     Unsafe.Add(ref refDestinationArray, destinationIndex - i) = value;
                 }
@@ -340,7 +340,7 @@ private static unsafe void CopyImplGcRefArray(Array sourceArray, int sourceIndex
                 for (int i = 0; i < length; i++)
                 {
                     object? value = Unsafe.Add(ref refSourceArray, sourceIndex + i);
-                    if (mustCastCheckEachElement && value != null && RuntimeImports.IsInstanceOf(destinationElementEEType, value) == null)
+                    if (mustCastCheckEachElement && value != null && TypeCast.IsInstanceOfAny(destinationElementEEType, value) == null)
                         throw new InvalidCastException(SR.InvalidCast_DownCastArrayElement);
                     Unsafe.Add(ref refDestinationArray, destinationIndex + i) = value;
                 }
@@ -370,7 +370,7 @@ private static unsafe void CopyImplValueTypeArrayToReferenceArray(Array sourceAr
                 ref object refDestinationArray = ref Unsafe.As<byte, object>(ref MemoryMarshal.GetArrayDataReference(destinationArray));
                 for (int i = 0; i < length; i++)
                 {
-                    object boxedValue = RuntimeImports.RhBox(sourceElementEEType, ref *pElement);
+                    object boxedValue = RuntimeExports.RhBox(sourceElementEEType, ref *pElement);
                     Unsafe.Add(ref refDestinationArray, destinationIndex + i) = boxedValue;
                     pElement += sourceElementSize;
                 }
@@ -457,7 +457,7 @@ private static unsafe void CopyImplValueTypeArrayWithInnerGcRefs(Array sourceArr
                         pDestinationElement -= cbElementSize;
                     }
 
-                    object boxedValue = RuntimeImports.RhBox(sourceElementEEType, ref *pSourceElement);
+                    object boxedValue = RuntimeExports.RhBox(sourceElementEEType, ref *pSourceElement);
                     if (boxedElements != null)
                         boxedElements[i] = boxedValue;
                     else
@@ -768,7 +768,7 @@ internal unsafe nint GetFlattenedIndex(ReadOnlySpan<int> indices)
             MethodTable* pElementEEType = ElementMethodTable;
             if (pElementEEType->IsValueType)
             {
-                return RuntimeImports.RhBox(pElementEEType, ref element);
+                return RuntimeExports.RhBox(pElementEEType, ref element);
             }
             else
             {
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/InvokeUtils.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/InvokeUtils.cs
@@ -133,7 +133,7 @@ private static Exception ConvertOrWidenPrimitivesEnumsAndPointersIfPossible(obje
             if (dstElementType == srcElementType)
             {
                 // Rebox the value if the EETypeElementTypes match
-                dstObject = RuntimeImports.RhBox(dstEEType, ref srcObject.GetRawData());
+                dstObject = RuntimeExports.RhBox(dstEEType, ref srcObject.GetRawData());
             }
             else
             {
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/DynamicInvokeInfo.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/DynamicInvokeInfo.cs
@@ -783,7 +783,7 @@ private unsafe void CopyBackToArray(ref object? src, object?[] dest)
                     }
                     else
                     {
-                        obj = RuntimeImports.RhBox(
+                        obj = RuntimeExports.RhBox(
                             (transform & Transform.FunctionPointer) != 0 ? MethodTable.Of<IntPtr>() : argumentInfo.Type,
                             ref obj.GetRawData());
                     }
@@ -818,7 +818,7 @@ private unsafe void CopyBackToSpan(Span<object?> src, Span<object?> dest)
                     }
                     else
                     {
-                        obj = RuntimeImports.RhBox(
+                        obj = RuntimeExports.RhBox(
                             (transform & Transform.FunctionPointer) != 0 ? MethodTable.Of<IntPtr>() : argumentInfo.Type,
                             ref obj.GetRawData());
                     }
@@ -849,7 +849,7 @@ private unsafe object ReturnTransform(ref byte byref, bool wrapInTargetInvocatio
             else if ((_returnTransform & Transform.FunctionPointer) != 0)
             {
                 Debug.Assert(Type.GetTypeFromMethodTable(_returnType).IsFunctionPointer);
-                obj = RuntimeImports.RhBox(MethodTable.Of<IntPtr>(), ref byref);
+                obj = RuntimeExports.RhBox(MethodTable.Of<IntPtr>(), ref byref);
             }
             else if ((_returnTransform & Transform.Reference) != 0)
             {
@@ -859,7 +859,7 @@ private unsafe object ReturnTransform(ref byte byref, bool wrapInTargetInvocatio
             else
             {
                 Debug.Assert((_returnTransform & (Transform.ByRef | Transform.Nullable)) != 0);
-                obj = RuntimeImports.RhBox(_returnType, ref byref);
+                obj = RuntimeExports.RhBox(_returnType, ref byref);
             }
             return obj;
         }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.NativeAot.cs
@@ -380,7 +380,7 @@ public static unsafe object GetUninitializedObject(
             if (mt->IsByRefLike)
                 throw new NotSupportedException(SR.NotSupported_ByRefLike);
 
-            return RuntimeImports.RhBox(mt, ref target);
+            return RuntimeExports.RhBox(mt, ref target);
         }
 
         /// <summary>
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs
@@ -379,10 +379,6 @@ internal static IntPtr RhHandleAllocDependent(object primary, object secondary)
         [RuntimeImport(RuntimeLibrary, "RhTypeCast_CheckArrayStore")]
         internal static extern void RhCheckArrayStore(object array, object? obj);
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        [RuntimeImport(RuntimeLibrary, "RhTypeCast_IsInstanceOfAny")]
-        internal static extern unsafe object IsInstanceOf(MethodTable* pTargetType, object obj);
-
         //
         // calls to runtime for allocation
         // These calls are needed in types which cannot use "new" to allocate and need to do it manually
@@ -405,10 +401,6 @@ internal static IntPtr RhHandleAllocDependent(object primary, object secondary)
         [RuntimeImport(RuntimeLibrary, "RhNewString")]
         internal static extern unsafe string RhNewString(MethodTable* pEEType, int length);
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        [RuntimeImport(RuntimeLibrary, "RhBox")]
-        internal static extern unsafe object RhBox(MethodTable* pEEType, ref byte data);
-
         [MethodImpl(MethodImplOptions.InternalCall)]
         [RuntimeImport(RuntimeLibrary, "RhUnbox")]
         internal static extern unsafe void RhUnbox(object? obj, ref byte data, MethodTable* pUnboxToEEType);
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/RuntimeType.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/RuntimeType.cs
@@ -630,7 +630,7 @@ public override bool IsInstanceOfType([NotNullWhen(true)] object? o)
                 return false;
             if (pEEType->IsNullable)
                 pEEType = pEEType->NullableType;
-            return RuntimeImports.IsInstanceOf(pEEType, o) != null;
+            return TypeCast.IsInstanceOfAny(pEEType, o) != null;
         }
 
         //
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/ValueType.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/ValueType.cs
@@ -146,7 +146,7 @@ private unsafe void RegularGetValueTypeHashCode(ref HashCode hashCode, ref byte
                     // of __GetFieldHelper, decodes the unboxing stub pointed to by the slot to the real target
                     // (we already have that part), and calls the entrypoint that expects a byref `this`, and use the
                     // data to decide between calling fast or regular hashcode helper.
-                    var fieldValue = (ValueType)RuntimeImports.RhBox(fieldType, ref fieldData);
+                    var fieldValue = (ValueType)RuntimeExports.RhBox(fieldType, ref fieldData);
                     if (fieldValue != null)
                     {
                         hashCode.Add(fieldValue);
diff --git a/src/coreclr/nativeaot/Test.CoreLib/src/System/Buffer.cs b/src/coreclr/nativeaot/Test.CoreLib/src/System/Buffer.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime;
+using System.Runtime.CompilerServices;
+
+namespace System
+{
+    public static partial class Buffer
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount) =>
+            RuntimeImports.RhBulkMoveWithWriteBarrier(ref destination, ref source, byteCount);
+    }
+}
diff --git a/src/coreclr/nativeaot/Test.CoreLib/src/System/SpanHelpers.cs b/src/coreclr/nativeaot/Test.CoreLib/src/System/SpanHelpers.cs
@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+
+namespace System
+{
+    internal static partial class SpanHelpers
+    {
+        [Intrinsic]
+        public static unsafe void ClearWithoutReferences(ref byte dest, nuint len)
+        {
+            Fill(ref dest, 0, len);
+        }
+
+        [Intrinsic]
+        internal static unsafe void Memmove(ref byte dest, ref byte src, nuint len)
+        {
+            if ((nuint)(nint)Unsafe.ByteOffset(ref src, ref dest) >= len)
+                for (nuint i = 0; i < len; i++)
+                    Unsafe.Add(ref dest, (nint)i) = Unsafe.Add(ref src, (nint)i);
+            else
+                for (nuint i = len; i > 0; i--)
+                    Unsafe.Add(ref dest, (nint)(i - 1)) = Unsafe.Add(ref src, (nint)(i - 1));
+        }
+
+
+        internal static void Fill(ref byte dest, byte value, nuint len)
+        {
+            for (nuint i = 0; i < len;  i++)
+                Unsafe.Add(ref dest, (nint)i) = value;
+        }
+    }
+}
diff --git a/src/coreclr/nativeaot/Test.CoreLib/src/Test.CoreLib.csproj b/src/coreclr/nativeaot/Test.CoreLib/src/Test.CoreLib.csproj
@@ -232,6 +232,8 @@
     <Compile Include="System\Runtime\InitializeFinalizerThread.cs" />
     <Compile Include="System\Threading\Interlocked.cs" />
     <Compile Include="System\Array.cs" />
+    <Compile Include="System\Buffer.cs" />
+    <Compile Include="System\SpanHelpers.cs" />
     <Compile Include="System\RuntimeExceptionHelpers.cs" />
     <Compile Include="System\Object.cs" />
     <Compile Include="System\Type.cs" />
diff --git a/src/coreclr/tools/Common/TypeSystem/IL/HelperExtensions.cs b/src/coreclr/tools/Common/TypeSystem/IL/HelperExtensions.cs
@@ -33,6 +33,12 @@ public static MethodDesc GetHelperEntryPoint(this TypeSystemContext context, str
             return helperMethod;
         }
 
+        public static MethodDesc GetCoreLibEntryPoint(this TypeSystemContext context, string namespaceName, string typeName, string methodName, MethodSignature signature)
+        {
+            MetadataType owningType = context.SystemModule.GetKnownType(namespaceName, typeName);
+            return owningType.GetKnownMethod(methodName, signature);
+        }
+
         public static MethodDesc GetOptionalHelperEntryPoint(this TypeSystemContext context, string typeName, string methodName)
         {
             MetadataType helperType = context.GetOptionalHelperType(typeName);
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ILScanner.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ILScanner.cs
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/JitHelper.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/JitHelper.cs
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffer.cs b/src/libraries/System.Private.CoreLib/src/System/Buffer.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.ByteMemOps.cs b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.ByteMemOps.cs

Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,6 @@ public static unsafe object RhNewArray(MethodTable* pEEType, int length)`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
`76`		`- [RuntimeExport("RhBox")]`
`77`	`76`	`public static unsafe object RhBox(MethodTable* pEEType, ref byte data)`
`78`	`77`	`{`
`79`	`78`	`// A null can be passed for boxing of a null ref.`
`@@ -207,7 +206,6 @@ public static unsafe void RhUnboxAny(object? o, ref byte data, MethodTable* pUnb`
`207`	`206`	`//`
`208`	`207`	`// Unbox helpers with RyuJIT conventions`
`209`	`208`	`//`
`210`		`- [RuntimeExport("RhUnbox2")]`
`211`	`209`	`public static unsafe ref byte RhUnbox2(MethodTable* pUnboxToEEType, object obj)`
`212`	`210`	`{`
`213`	`211`	`if ((obj == null) \|\| !UnboxAnyTypeCompare(obj.GetMethodTable(), pUnboxToEEType))`
`@@ -218,7 +216,6 @@ public static unsafe ref byte RhUnbox2(MethodTable* pUnboxToEEType, object obj)`
`218`	`216`	`return ref obj.GetRawData();`
`219`	`217`	`}`
`220`	`218`
`221`		`- [RuntimeExport("RhUnboxNullable")]`
`222`	`219`	`public static unsafe void RhUnboxNullable(ref byte data, MethodTable* pUnboxToEEType, object obj)`
`223`	`220`	`{`
`224`	`221`	`if (obj != null && obj.GetMethodTable() != pUnboxToEEType->NullableType)`
`@@ -228,7 +225,6 @@ public static unsafe void RhUnboxNullable(ref byte data, MethodTable* pUnboxToEE`
`228`	`225`	`RhUnbox(obj, ref data, pUnboxToEEType);`
`229`	`226`	`}`
`230`	`227`
`231`		`- [RuntimeExport("RhUnboxTypeTest")]`
`232`	`228`	`public static unsafe void RhUnboxTypeTest(MethodTable* pType, MethodTable* pBoxType)`
`233`	`229`	`{`
`234`	`230`	`Debug.Assert(pType->IsValueType);`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,6 @@ internal enum AssignmentVariation`
`63`	`63`	`// IsInstanceOf test used for unusual cases (naked type parameters, variant generic types)`
`64`	`64`	`// Unlike the IsInstanceOfInterface and IsInstanceOfClass functions,`
`65`	`65`	`// this test must deal with all kinds of type tests`
`66`		`- [RuntimeExport("RhTypeCast_IsInstanceOfAny")]`
`67`	`66`	`public static unsafe object? IsInstanceOfAny(MethodTable* pTargetType, object? obj)`
`68`	`67`	`{`
`69`	`68`	`if (obj != null)`
`@@ -94,7 +93,6 @@ internal enum AssignmentVariation`
`94`	`93`	`return IsInstanceOfAny_NoCacheLookup(pTargetType, obj);`
`95`	`94`	`}`
`96`	`95`
`97`		`- [RuntimeExport("RhTypeCast_IsInstanceOfInterface")]`
`98`	`96`	`public static unsafe object? IsInstanceOfInterface(MethodTable* pTargetType, object? obj)`
`99`	`97`	`{`
`100`	`98`	`Debug.Assert(pTargetType->IsInterface);`
`@@ -184,7 +182,6 @@ internal enum AssignmentVariation`
`184`	`182`	`return obj;`
`185`	`183`	`}`
`186`	`184`
`187`		`- [RuntimeExport("RhTypeCast_IsInstanceOfClass")]`
`188`	`185`	`public static unsafe object? IsInstanceOfClass(MethodTable* pTargetType, object? obj)`
`189`	`186`	`{`
`190`	`187`	`Debug.Assert(!pTargetType->IsParameterizedType, "IsInstanceOfClass called with parameterized MethodTable");`
`@@ -248,7 +245,6 @@ internal enum AssignmentVariation`
`248`	`245`	`return obj;`
`249`	`246`	`}`
`250`	`247`
`251`		`- [RuntimeExport("RhTypeCast_IsInstanceOfException")]`
`252`	`248`	`public static unsafe bool IsInstanceOfException(MethodTable* pTargetType, object? obj)`
`253`	`249`	`{`
`254`	`250`	`// Based on IsInstanceOfClass`
`@@ -279,7 +275,6 @@ public static unsafe bool IsInstanceOfException(MethodTable* pTargetType, object`
`279`	`275`	`// ChkCast test used for unusual cases (naked type parameters, variant generic types)`
`280`	`276`	`// Unlike the ChkCastInterface and ChkCastClass functions,`
`281`	`277`	`// this test must deal with all kinds of type tests`
`282`		`- [RuntimeExport("RhTypeCast_CheckCastAny")]`
`283`	`278`	`public static unsafe object CheckCastAny(MethodTable* pTargetType, object obj)`
`284`	`279`	`{`
`285`	`280`	`CastResult result;`
`@@ -307,7 +302,6 @@ public static unsafe object CheckCastAny(MethodTable* pTargetType, object obj)`
`307`	`302`	`return objRet;`
`308`	`303`	`}`
`309`	`304`
`310`		`- [RuntimeExport("RhTypeCast_CheckCastInterface")]`
`311`	`305`	`public static unsafe object CheckCastInterface(MethodTable* pTargetType, object obj)`
`312`	`306`	`{`
`313`	`307`	`Debug.Assert(pTargetType->IsInterface);`
`@@ -393,7 +387,6 @@ private static unsafe object CheckCastInterface_Helper(MethodTable* pTargetType,`
`393`	`387`	`return ThrowInvalidCastException(pTargetType);`
`394`	`388`	`}`
`395`	`389`
`396`		`- [RuntimeExport("RhTypeCast_CheckCastClass")]`
`397`	`390`	`public static unsafe object CheckCastClass(MethodTable* pTargetType, object obj)`
`398`	`391`	`{`
`399`	`392`	`Debug.Assert(!pTargetType->IsParameterizedType, "CheckCastClass called with parameterized MethodTable");`
`@@ -411,7 +404,6 @@ public static unsafe object CheckCastClass(MethodTable* pTargetType, object obj)`
`411`	`404`
`412`	`405`	`// Optimized helper for classes. Assumes that the trivial cases`
`413`	`406`	`// has been taken care of by the inlined check`
`414`		`- [RuntimeExport("RhTypeCast_CheckCastClassSpecial")]`
`415`	`407`	`private static unsafe object CheckCastClassSpecial(MethodTable* pTargetType, object obj)`
`416`	`408`	`{`
`417`	`409`	`Debug.Assert(!pTargetType->IsParameterizedType, "CheckCastClassSpecial called with parameterized MethodTable");`
`@@ -761,8 +753,6 @@ private static unsafe void ThrowArrayMismatchException(object?[] array)`
`761`	`753`	`//`
`762`	`754`	`// Array stelem/ldelema helpers with RyuJIT conventions`
`763`	`755`	`//`
`764`		`-`
`765`		`- [RuntimeExport("RhpLdelemaRef")]`
`766`	`756`	`public static unsafe ref object? LdelemaRef(object?[] array, nint index, MethodTable* elementType)`
`767`	`757`	`{`
`768`	`758`	`Debug.Assert(array is null \|\| array.GetMethodTable()->IsArray, "first argument must be an array");`
`@@ -794,7 +784,6 @@ private static unsafe void ThrowArrayMismatchException(object?[] array)`
`794`	`784`	`return ref element;`
`795`	`785`	`}`
`796`	`786`
`797`		`- [RuntimeExport("RhpStelemRef")]`
`798`	`787`	`public static unsafe void StelemRef(object?[] array, nint index, object? obj)`
`799`	`788`	`{`
`800`	`789`	`// This is supported only on arrays`
Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,7 @@ public static unsafe void StoreValueTypeField(IntPtr address, object fieldValue,`
`216`	`216`
`217`	`217`	`public static unsafe object LoadValueTypeField(IntPtr address, RuntimeTypeHandle fieldType)`
`218`	`218`	`{`
`219`		`- return RuntimeImports.RhBox(fieldType.ToMethodTable(), ref (byte)address);`
	`219`	`+ return RuntimeExports.RhBox(fieldType.ToMethodTable(), ref (byte)address);`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`public static unsafe object LoadPointerTypeField(IntPtr address, RuntimeTypeHandle fieldType)`
`@@ -236,15 +236,15 @@ public static unsafe void StoreValueTypeField(object obj, int fieldOffset, objec`
`236`	`236`	`public static unsafe object LoadValueTypeField(object obj, int fieldOffset, RuntimeTypeHandle fieldType)`
`237`	`237`	`{`
`238`	`238`	`ref byte address = ref Unsafe.AddByteOffset(ref obj.GetRawData(), new IntPtr(fieldOffset - ObjectHeaderSize));`
`239`		`- return RuntimeImports.RhBox(fieldType.ToMethodTable(), ref address);`
	`239`	`+ return RuntimeExports.RhBox(fieldType.ToMethodTable(), ref address);`
`240`	`240`	`}`
`241`	`241`
`242`	`242`	`public static unsafe object LoadPointerTypeField(object obj, int fieldOffset, RuntimeTypeHandle fieldType)`
`243`	`243`	`{`
`244`	`244`	`ref byte address = ref Unsafe.AddByteOffset(ref obj.GetRawData(), new IntPtr(fieldOffset - ObjectHeaderSize));`
`245`	`245`
`246`	`246`	`if (fieldType.ToMethodTable()->IsFunctionPointer)`
`247`		`- return RuntimeImports.RhBox(MethodTable.Of<IntPtr>(), ref address);`
	`247`	`+ return RuntimeExports.RhBox(MethodTable.Of<IntPtr>(), ref address);`
`248`	`248`
`249`	`249`	`return ReflectionPointer.Box((void*)Unsafe.As<byte, IntPtr>(ref address), Type.GetTypeFromHandle(fieldType));`
`250`	`250`	`}`
`@@ -285,7 +285,7 @@ public static object LoadValueTypeFieldValueFromValueType(TypedReference typedRe`
`285`	`285`	`Debug.Assert(TypedReference.TargetTypeToken(typedReference).ToMethodTable()->IsValueType);`
`286`	`286`	`Debug.Assert(fieldTypeHandle.ToMethodTable()->IsValueType);`
`287`	`287`
`288`		`- return RuntimeImports.RhBox(fieldTypeHandle.ToMethodTable(), ref Unsafe.Add<byte>(ref typedReference.Value, fieldOffset));`
	`288`	`+ return RuntimeExports.RhBox(fieldTypeHandle.ToMethodTable(), ref Unsafe.Add<byte>(ref typedReference.Value, fieldOffset));`
`289`	`289`	`}`
`290`	`290`
`291`	`291`	`[CLSCompliant(false)]`
`@@ -391,7 +391,7 @@ public static bool IsInterface(RuntimeTypeHandle type)`
`391`	`391`
`392`	`392`	`public static unsafe object Box(RuntimeTypeHandle type, IntPtr address)`
`393`	`393`	`{`
`394`		`- return RuntimeImports.RhBox(type.ToMethodTable(), ref (byte)address);`
	`394`	`+ return RuntimeExports.RhBox(type.ToMethodTable(), ref (byte)address);`
`395`	`395`	`}`
`396`	`396`
`397`	`397`	`//==============================================================================================`
Original file line number	Diff line number	Diff line change
`@@ -330,7 +330,7 @@ private static unsafe void CopyImplGcRefArray(Array sourceArray, int sourceIndex`
`330`	`330`	`for (int i = 0; i < length; i++)`
`331`	`331`	`{`
`332`	`332`	`object? value = Unsafe.Add(ref refSourceArray, sourceIndex - i);`
`333`		`- if (mustCastCheckEachElement && value != null && RuntimeImports.IsInstanceOf(destinationElementEEType, value) == null)`
	`333`	`+ if (mustCastCheckEachElement && value != null && TypeCast.IsInstanceOfAny(destinationElementEEType, value) == null)`
`334`	`334`	`throw new InvalidCastException(SR.InvalidCast_DownCastArrayElement);`
`335`	`335`	`Unsafe.Add(ref refDestinationArray, destinationIndex - i) = value;`
`336`	`336`	`}`
`@@ -340,7 +340,7 @@ private static unsafe void CopyImplGcRefArray(Array sourceArray, int sourceIndex`
`340`	`340`	`for (int i = 0; i < length; i++)`
`341`	`341`	`{`
`342`	`342`	`object? value = Unsafe.Add(ref refSourceArray, sourceIndex + i);`
`343`		`- if (mustCastCheckEachElement && value != null && RuntimeImports.IsInstanceOf(destinationElementEEType, value) == null)`
	`343`	`+ if (mustCastCheckEachElement && value != null && TypeCast.IsInstanceOfAny(destinationElementEEType, value) == null)`
`344`	`344`	`throw new InvalidCastException(SR.InvalidCast_DownCastArrayElement);`
`345`	`345`	`Unsafe.Add(ref refDestinationArray, destinationIndex + i) = value;`
`346`	`346`	`}`
`@@ -370,7 +370,7 @@ private static unsafe void CopyImplValueTypeArrayToReferenceArray(Array sourceAr`
`370`	`370`	`ref object refDestinationArray = ref Unsafe.As<byte, object>(ref MemoryMarshal.GetArrayDataReference(destinationArray));`
`371`	`371`	`for (int i = 0; i < length; i++)`
`372`	`372`	`{`
`373`		`- object boxedValue = RuntimeImports.RhBox(sourceElementEEType, ref *pElement);`
	`373`	`+ object boxedValue = RuntimeExports.RhBox(sourceElementEEType, ref *pElement);`
`374`	`374`	`Unsafe.Add(ref refDestinationArray, destinationIndex + i) = boxedValue;`
`375`	`375`	`pElement += sourceElementSize;`
`376`	`376`	`}`
`@@ -457,7 +457,7 @@ private static unsafe void CopyImplValueTypeArrayWithInnerGcRefs(Array sourceArr`
`457`	`457`	`pDestinationElement -= cbElementSize;`
`458`	`458`	`}`
`459`	`459`
`460`		`- object boxedValue = RuntimeImports.RhBox(sourceElementEEType, ref *pSourceElement);`
	`460`	`+ object boxedValue = RuntimeExports.RhBox(sourceElementEEType, ref *pSourceElement);`
`461`	`461`	`if (boxedElements != null)`
`462`	`462`	`boxedElements[i] = boxedValue;`
`463`	`463`	`else`
`@@ -768,7 +768,7 @@ internal unsafe nint GetFlattenedIndex(ReadOnlySpan<int> indices)`
`768`	`768`	`MethodTable* pElementEEType = ElementMethodTable;`
`769`	`769`	`if (pElementEEType->IsValueType)`
`770`	`770`	`{`
`771`		`- return RuntimeImports.RhBox(pElementEEType, ref element);`
	`771`	`+ return RuntimeExports.RhBox(pElementEEType, ref element);`
`772`	`772`	`}`
`773`	`773`	`else`
`774`	`774`	`{`
Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ private static Exception ConvertOrWidenPrimitivesEnumsAndPointersIfPossible(obje`
`133`	`133`	`if (dstElementType == srcElementType)`
`134`	`134`	`{`
`135`	`135`	`// Rebox the value if the EETypeElementTypes match`
`136`		`- dstObject = RuntimeImports.RhBox(dstEEType, ref srcObject.GetRawData());`
	`136`	`+ dstObject = RuntimeExports.RhBox(dstEEType, ref srcObject.GetRawData());`
`137`	`137`	`}`
`138`	`138`	`else`
`139`	`139`	`{`
Original file line number	Diff line number	Diff line change
`@@ -783,7 +783,7 @@ private unsafe void CopyBackToArray(ref object? src, object?[] dest)`
`783`	`783`	`}`
`784`	`784`	`else`
`785`	`785`	`{`
`786`		`- obj = RuntimeImports.RhBox(`
	`786`	`+ obj = RuntimeExports.RhBox(`
`787`	`787`	`(transform & Transform.FunctionPointer) != 0 ? MethodTable.Of<IntPtr>() : argumentInfo.Type,`
`788`	`788`	`ref obj.GetRawData());`
`789`	`789`	`}`
`@@ -818,7 +818,7 @@ private unsafe void CopyBackToSpan(Span<object?> src, Span<object?> dest)`
`818`	`818`	`}`
`819`	`819`	`else`
`820`	`820`	`{`
`821`		`- obj = RuntimeImports.RhBox(`
	`821`	`+ obj = RuntimeExports.RhBox(`
`822`	`822`	`(transform & Transform.FunctionPointer) != 0 ? MethodTable.Of<IntPtr>() : argumentInfo.Type,`
`823`	`823`	`ref obj.GetRawData());`
`824`	`824`	`}`
`@@ -849,7 +849,7 @@ private unsafe object ReturnTransform(ref byte byref, bool wrapInTargetInvocatio`
`849`	`849`	`else if ((_returnTransform & Transform.FunctionPointer) != 0)`
`850`	`850`	`{`
`851`	`851`	`Debug.Assert(Type.GetTypeFromMethodTable(_returnType).IsFunctionPointer);`
`852`		`- obj = RuntimeImports.RhBox(MethodTable.Of<IntPtr>(), ref byref);`
	`852`	`+ obj = RuntimeExports.RhBox(MethodTable.Of<IntPtr>(), ref byref);`
`853`	`853`	`}`
`854`	`854`	`else if ((_returnTransform & Transform.Reference) != 0)`
`855`	`855`	`{`
`@@ -859,7 +859,7 @@ private unsafe object ReturnTransform(ref byte byref, bool wrapInTargetInvocatio`
`859`	`859`	`else`
`860`	`860`	`{`
`861`	`861`	`Debug.Assert((_returnTransform & (Transform.ByRef \| Transform.Nullable)) != 0);`
`862`		`- obj = RuntimeImports.RhBox(_returnType, ref byref);`
	`862`	`+ obj = RuntimeExports.RhBox(_returnType, ref byref);`
`863`	`863`	`}`
`864`	`864`	`return obj;`
`865`	`865`	`}`
Original file line number	Diff line number	Diff line change
`@@ -380,7 +380,7 @@ public static unsafe object GetUninitializedObject(`
`380`	`380`	`if (mt->IsByRefLike)`
`381`	`381`	`throw new NotSupportedException(SR.NotSupported_ByRefLike);`
`382`	`382`
`383`		`- return RuntimeImports.RhBox(mt, ref target);`
	`383`	`+ return RuntimeExports.RhBox(mt, ref target);`
`384`	`384`	`}`
`385`	`385`
`386`	`386`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -630,7 +630,7 @@ public override bool IsInstanceOfType([NotNullWhen(true)] object? o)`
`630`	`630`	`return false;`
`631`	`631`	`if (pEEType->IsNullable)`
`632`	`632`	`pEEType = pEEType->NullableType;`
`633`		`- return RuntimeImports.IsInstanceOf(pEEType, o) != null;`
	`633`	`+ return TypeCast.IsInstanceOfAny(pEEType, o) != null;`
`634`	`634`	`}`
`635`	`635`
`636`	`636`	`//`