Block implementation details on System.Object (#67574)

When reflection blocking is disabled (like we do for libraries tests), still block implementation details on System.Object because tests (or anyone else for that matter) don't like to see them. Move implementation details methods on System.Object elsewhere.

Author: MichalStrehovsky

src/coreclr/jit/importer.cpp

@@ -3868,11 +3868,11 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
             mustExpand |= IsTargetAbi(CORINFO_CORERT_ABI);
             break;
 
+        case NI_Internal_Runtime_MethodTable_Of:
         case NI_System_ByReference_ctor:
         case NI_System_ByReference_get_Value:
         case NI_System_Activator_AllocatorOf:
         case NI_System_Activator_DefaultConstructorOf:
-        case NI_System_Object_MethodTableOf:
         case NI_System_EETypePtr_EETypePtrOf:
             mustExpand = true;
             break;
@@ -4037,9 +4037,9 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
                 break;
             }
 
+            case NI_Internal_Runtime_MethodTable_Of:
             case NI_System_Activator_AllocatorOf:
             case NI_System_Activator_DefaultConstructorOf:
-            case NI_System_Object_MethodTableOf:
             case NI_System_EETypePtr_EETypePtrOf:
             {
                 assert(IsTargetAbi(CORINFO_CORERT_ABI)); // Only CoreRT supports it.
@@ -5233,10 +5233,6 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
             {
                 result = NI_System_Object_GetType;
             }
-            else if (strcmp(methodName, "MethodTableOf") == 0)
-            {
-                result = NI_System_Object_MethodTableOf;
-            }
         }
         else if (strcmp(className, "RuntimeTypeHandle") == 0)
         {
@@ -5336,6 +5332,16 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
             }
         }
     }
+    else if (strcmp(namespaceName, "Internal.Runtime") == 0)
+    {
+        if (strcmp(className, "MethodTable") == 0)
+        {
+            if (strcmp(methodName, "Of") == 0)
+            {
+                result = NI_Internal_Runtime_MethodTable_Of;
+            }
+        }
+    }
     else if (strcmp(namespaceName, "System.Threading") == 0)
     {
         if (strcmp(className, "Thread") == 0)

src/coreclr/jit/namedintrinsiclist.h

@@ -79,9 +79,10 @@ enum NamedIntrinsic : unsigned short
     NI_System_ByReference_get_Value,
     NI_System_Activator_AllocatorOf,
     NI_System_Activator_DefaultConstructorOf,
-    NI_System_Object_MethodTableOf,
     NI_System_EETypePtr_EETypePtrOf,
 
+    NI_Internal_Runtime_MethodTable_Of,
+
     NI_System_Runtime_CompilerServices_RuntimeHelpers_CreateSpan,
     NI_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray,
     NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant,

src/coreclr/nativeaot/Common/src/Internal/Runtime/CompilerHelpers/StartupCodeHelpers.cs

@@ -239,7 +239,7 @@ private static unsafe object[] InitializeStatics(IntPtr gcStaticRegionStart, int
                         // It actually has all GC fields including non-preinitialized fields and we simply copy over the
                         // entire blob to this object, overwriting everything.
                         IntPtr pPreInitDataAddr = *(pBlock + 1);
-                        RuntimeImports.RhBulkMoveWithWriteBarrier(ref obj.GetRawData(), ref *(byte *)pPreInitDataAddr, obj.GetRawDataSize());
+                        RuntimeImports.RhBulkMoveWithWriteBarrier(ref obj.GetRawData(), ref *(byte *)pPreInitDataAddr, obj.GetRawObjectDataSize());
                     }
 
                     // Call write barrier directly. Assigning object reference does a type check.

src/coreclr/nativeaot/Common/src/Internal/Runtime/MethodTable.cs

@@ -201,6 +201,9 @@ internal static bool SupportsWritableData
             }
         }
 
+        [Intrinsic]
+        internal static extern MethodTable* Of<T>();
+
         private ushort _usComponentSize;
         private ushort _usFlags;
         private uint _uBaseSize;

src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/CachedInterfaceDispatch.cs

@@ -31,9 +31,9 @@ private static IntPtr RhpCidResolve_Worker(object pObject, IntPtr pCell)
                 // We don't update the dispatch cell cache if this is IDynamicInterfaceCastable because this
                 // scenario is by-design dynamic. There is no guarantee that another instance with the same MethodTable
                 // as the one we just resolved would do the resolution the same way. We will need to ask again.
-                if (!pObject.MethodTable->IsIDynamicInterfaceCastable)
+                if (!pObject.GetMethodTable()->IsIDynamicInterfaceCastable)
                 {
-                    return InternalCalls.RhpUpdateDispatchCellCache(pCell, pTargetCode, pObject.MethodTable, ref cellInfo);
+                    return InternalCalls.RhpUpdateDispatchCellCache(pCell, pTargetCode, pObject.GetMethodTable(), ref cellInfo);
                 }
                 else
                 {
@@ -56,7 +56,7 @@ private static IntPtr RhpResolveInterfaceMethod(object pObject, IntPtr pCell)
                 return IntPtr.Zero;
             }
 
-            MethodTable* pInstanceType = pObject.MethodTable;
+            MethodTable* pInstanceType = pObject.GetMethodTable();
 
             // This method is used for the implementation of LOAD_VIRT_FUNCTION and in that case the mapping we want
             // may already be in the cache.
@@ -98,7 +98,7 @@ private static IntPtr RhResolveDispatchOnType(EETypePtr instanceType, EETypePtr
         private static unsafe IntPtr RhResolveDispatchWorker(object pObject, void* cell, ref DispatchCellInfo cellInfo)
         {
             // Type of object we're dispatching on.
-            MethodTable* pInstanceType = pObject.MethodTable;
+            MethodTable* pInstanceType = pObject.GetMethodTable();
 
             if (cellInfo.CellType == DispatchCellType.InterfaceAndSlot)
             {

src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs

@@ -141,7 +141,7 @@ private struct OSCONTEXT
         private static void OnFirstChanceExceptionViaClassLib(object exception)
         {
             IntPtr pOnFirstChanceFunction =
-                (IntPtr)InternalCalls.RhpGetClasslibFunctionFromEEType(exception.MethodTable, ClassLibFunctionId.OnFirstChance);
+                (IntPtr)InternalCalls.RhpGetClasslibFunctionFromEEType(exception.GetMethodTable(), ClassLibFunctionId.OnFirstChance);
 
             if (pOnFirstChanceFunction == IntPtr.Zero)
             {
@@ -161,7 +161,7 @@ private static void OnFirstChanceExceptionViaClassLib(object exception)
         private static void OnUnhandledExceptionViaClassLib(object exception)
         {
             IntPtr pOnUnhandledExceptionFunction =
-                (IntPtr)InternalCalls.RhpGetClasslibFunctionFromEEType(exception.MethodTable, ClassLibFunctionId.OnUnhandledException);
+                (IntPtr)InternalCalls.RhpGetClasslibFunctionFromEEType(exception.GetMethodTable(), ClassLibFunctionId.OnUnhandledException);
 
             if (pOnUnhandledExceptionFunction == IntPtr.Zero)
             {

src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/RuntimeExports.cs

@@ -171,11 +171,11 @@ public static unsafe void RhUnboxAny(object? o, ref byte data, EETypePtr pUnboxT
 
                 if (ptrUnboxToEEType->IsNullable)
                 {
-                    isValid = (o == null) || TypeCast.AreTypesEquivalent(o.MethodTable, ptrUnboxToEEType->NullableType);
+                    isValid = (o == null) || TypeCast.AreTypesEquivalent(o.GetMethodTable(), ptrUnboxToEEType->NullableType);
                 }
                 else
                 {
-                    isValid = (o != null) && UnboxAnyTypeCompare(o.MethodTable, ptrUnboxToEEType);
+                    isValid = (o != null) && UnboxAnyTypeCompare(o.GetMethodTable(), ptrUnboxToEEType);
                 }
 
                 if (!isValid)
@@ -207,7 +207,7 @@ public static unsafe void RhUnboxAny(object? o, ref byte data, EETypePtr pUnboxT
         [RuntimeExport("RhUnbox2")]
         public static unsafe ref byte RhUnbox2(MethodTable* pUnboxToEEType, object obj)
         {
-            if ((obj == null) || !UnboxAnyTypeCompare(obj.MethodTable, pUnboxToEEType))
+            if ((obj == null) || !UnboxAnyTypeCompare(obj.GetMethodTable(), pUnboxToEEType))
             {
                 ExceptionIDs exID = obj == null ? ExceptionIDs.NullReference : ExceptionIDs.InvalidCast;
                 throw pUnboxToEEType->GetClasslibException(exID);
@@ -218,7 +218,7 @@ public static unsafe ref byte RhUnbox2(MethodTable* pUnboxToEEType, object obj)
         [RuntimeExport("RhUnboxNullable")]
         public static unsafe void RhUnboxNullable(ref byte data, MethodTable* pUnboxToEEType, object obj)
         {
-            if ((obj != null) && !TypeCast.AreTypesEquivalent(obj.MethodTable, pUnboxToEEType->NullableType))
+            if ((obj != null) && !TypeCast.AreTypesEquivalent(obj.GetMethodTable(), pUnboxToEEType->NullableType))
             {
                 throw pUnboxToEEType->GetClasslibException(ExceptionIDs.InvalidCast);
             }
@@ -242,7 +242,7 @@ public static unsafe void RhUnbox(object? obj, ref byte data, MethodTable* pUnbo
                 return;
             }
 
-            MethodTable* pEEType = obj.MethodTable;
+            MethodTable* pEEType = obj.GetMethodTable();
 
             // Can unbox value types only.
             Debug.Assert(pEEType->IsValueType);
@@ -282,10 +282,10 @@ public static unsafe object RhMemberwiseClone(object src)
         {
             object objClone;
 
-            if (src.MethodTable->IsArray)
-                objClone = RhNewArray(src.MethodTable, Unsafe.As<Array>(src).Length);
+            if (src.GetMethodTable()->IsArray)
+                objClone = RhNewArray(src.GetMethodTable(), Unsafe.As<Array>(src).Length);
             else
-                objClone = RhNewObject(src.MethodTable);
+                objClone = RhNewObject(src.GetMethodTable());
 
             InternalCalls.RhpCopyObjectContents(objClone, src);
 

src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs

@@ -44,12 +44,12 @@ internal enum AssignmentVariation
         [RuntimeExport("RhTypeCast_IsInstanceOfClass")]
         public static unsafe object IsInstanceOfClass(MethodTable* pTargetType, object obj)
         {
-            if (obj == null || obj.MethodTable == pTargetType)
+            if (obj == null || obj.GetMethodTable() == pTargetType)
             {
                 return obj;
             }
 
-            MethodTable* pObjType = obj.MethodTable;
+            MethodTable* pObjType = obj.GetMethodTable();
 
             Debug.Assert(!pTargetType->IsParameterizedType, "IsInstanceOfClass called with parameterized MethodTable");
             Debug.Assert(!pTargetType->IsInterface, "IsInstanceOfClass called with interface MethodTable");
@@ -177,7 +177,7 @@ public static unsafe object IsInstanceOfArray(MethodTable* pTargetType, object o
                 return null;
             }
 
-            MethodTable* pObjType = obj.MethodTable;
+            MethodTable* pObjType = obj.GetMethodTable();
 
             Debug.Assert(pTargetType->IsArray, "IsInstanceOfArray called with non-array MethodTable");
             Debug.Assert(!pTargetType->IsCloned, "cloned array types are disallowed");
@@ -244,7 +244,7 @@ public static unsafe object IsInstanceOfInterface(MethodTable* pTargetType, obje
                 return null;
             }
 
-            MethodTable* pObjType = obj.MethodTable;
+            MethodTable* pObjType = obj.GetMethodTable();
 
             if (CastCache.AreTypesAssignableInternal_SourceNotTarget_BoxedSource(pObjType, pTargetType, null))
                 return obj;
@@ -661,7 +661,7 @@ public static unsafe object CheckCastInterface(MethodTable* pTargetType, object
                 return null;
             }
 
-            MethodTable* pObjType = obj.MethodTable;
+            MethodTable* pObjType = obj.GetMethodTable();
 
             if (CastCache.AreTypesAssignableInternal_SourceNotTarget_BoxedSource(pObjType, pTargetType, null))
                 return obj;
@@ -687,21 +687,21 @@ public static unsafe void CheckArrayStore(object array, object obj)
                 return;
             }
 
-            Debug.Assert(array.MethodTable->IsArray, "first argument must be an array");
+            Debug.Assert(array.GetMethodTable()->IsArray, "first argument must be an array");
 
-            MethodTable* arrayElemType = array.MethodTable->RelatedParameterType;
-            if (CastCache.AreTypesAssignableInternal(obj.MethodTable, arrayElemType, AssignmentVariation.BoxedSource, null))
+            MethodTable* arrayElemType = array.GetMethodTable()->RelatedParameterType;
+            if (CastCache.AreTypesAssignableInternal(obj.GetMethodTable(), arrayElemType, AssignmentVariation.BoxedSource, null))
                 return;
 
             // If object type implements IDynamicInterfaceCastable then there's one more way to check whether it implements
             // the interface.
-            if (obj.MethodTable->IsIDynamicInterfaceCastable && IsInstanceOfInterfaceViaIDynamicInterfaceCastable(arrayElemType, obj, throwing: false))
+            if (obj.GetMethodTable()->IsIDynamicInterfaceCastable && IsInstanceOfInterfaceViaIDynamicInterfaceCastable(arrayElemType, obj, throwing: false))
                 return;
 
             // Throw the array type mismatch exception defined by the classlib, using the input array's MethodTable*
             // to find the correct classlib.
 
-            throw array.MethodTable->GetClasslibException(ExceptionIDs.ArrayTypeMismatch);
+            throw array.GetMethodTable()->GetClasslibException(ExceptionIDs.ArrayTypeMismatch);
         }
 
         [RuntimeExport("RhTypeCast_CheckVectorElemAddr")]
@@ -712,9 +712,9 @@ public static unsafe void CheckVectorElemAddr(MethodTable* elemType, object arra
                 return;
             }
 
-            Debug.Assert(array.MethodTable->IsArray, "second argument must be an array");
+            Debug.Assert(array.GetMethodTable()->IsArray, "second argument must be an array");
 
-            MethodTable* arrayElemType = array.MethodTable->RelatedParameterType;
+            MethodTable* arrayElemType = array.GetMethodTable()->RelatedParameterType;
 
             if (!AreTypesEquivalent(elemType, arrayElemType)
             // In addition to the exactness check, add another check to allow non-exact matches through
@@ -730,7 +730,7 @@ public static unsafe void CheckVectorElemAddr(MethodTable* elemType, object arra
                 // Throw the array type mismatch exception defined by the classlib, using the input array's MethodTable*
                 // to find the correct classlib.
 
-                throw array.MethodTable->GetClasslibException(ExceptionIDs.ArrayTypeMismatch);
+                throw array.GetMethodTable()->GetClasslibException(ExceptionIDs.ArrayTypeMismatch);
             }
         }
 
@@ -746,7 +746,7 @@ internal struct ArrayElement
         public static unsafe void StelemRef(Array array, int index, object obj)
         {
             // This is supported only on arrays
-            Debug.Assert(array.MethodTable->IsArray, "first argument must be an array");
+            Debug.Assert(array.GetMethodTable()->IsArray, "first argument must be an array");
 
 #if INPLACE_RUNTIME
             // this will throw appropriate exceptions if array is null or access is out of range.
@@ -766,12 +766,12 @@ public static unsafe void StelemRef(Array array, int index, object obj)
             ref object element = ref Unsafe.Add(ref rawData, index);
 #endif
 
-            MethodTable* elementType = array.MethodTable->RelatedParameterType;
+            MethodTable* elementType = array.GetMethodTable()->RelatedParameterType;
 
             if (obj == null)
                 goto assigningNull;
 
-            if (elementType != obj.MethodTable)
+            if (elementType != obj.GetMethodTable())
                 goto notExactMatch;
 
 doWrite:
@@ -785,7 +785,7 @@ public static unsafe void StelemRef(Array array, int index, object obj)
         notExactMatch:
 #if INPLACE_RUNTIME
             // This optimization only makes sense for inplace runtime where there's only one System.Object.
-            if (array.MethodTable == MethodTableOf<object[]>())
+            if (array.GetMethodTable() == MethodTable.Of<object[]>())
                 goto doWrite;
 #endif
 
@@ -795,15 +795,15 @@ public static unsafe void StelemRef(Array array, int index, object obj)
         [MethodImpl(MethodImplOptions.NoInlining)]
         private static unsafe void StelemRef_Helper(ref object element, MethodTable* elementType, object obj)
         {
-            if (CastCache.AreTypesAssignableInternal(obj.MethodTable, elementType, AssignmentVariation.BoxedSource, null))
+            if (CastCache.AreTypesAssignableInternal(obj.GetMethodTable(), elementType, AssignmentVariation.BoxedSource, null))
             {
                 InternalCalls.RhpAssignRef(ref element, obj);
             }
             else
             {
                 // If object type implements IDynamicInterfaceCastable then there's one more way to check whether it implements
                 // the interface.
-                if (!obj.MethodTable->IsIDynamicInterfaceCastable || !IsInstanceOfInterfaceViaIDynamicInterfaceCastable(elementType, obj, throwing: false))
+                if (!obj.GetMethodTable()->IsIDynamicInterfaceCastable || !IsInstanceOfInterfaceViaIDynamicInterfaceCastable(elementType, obj, throwing: false))
                 {
                     // Throw the array type mismatch exception defined by the classlib, using the input array's
                     // MethodTable* to find the correct classlib.
@@ -816,17 +816,17 @@ private static unsafe void StelemRef_Helper(ref object element, MethodTable* ele
         [RuntimeExport("RhpLdelemaRef")]
         public static unsafe ref object LdelemaRef(Array array, int index, IntPtr elementType)
         {
-            Debug.Assert(array.MethodTable->IsArray, "first argument must be an array");
+            Debug.Assert(array.GetMethodTable()->IsArray, "first argument must be an array");
 
             MethodTable* elemType = (MethodTable*)elementType;
-            MethodTable* arrayElemType = array.MethodTable->RelatedParameterType;
+            MethodTable* arrayElemType = array.GetMethodTable()->RelatedParameterType;
 
             if (!AreTypesEquivalent(elemType, arrayElemType))
             {
                 // Throw the array type mismatch exception defined by the classlib, using the input array's MethodTable*
                 // to find the correct classlib.
 
-                throw array.MethodTable->GetClasslibException(ExceptionIDs.ArrayTypeMismatch);
+                throw array.GetMethodTable()->GetClasslibException(ExceptionIDs.ArrayTypeMismatch);
             }
 
             ref object rawData = ref Unsafe.As<byte, object>(ref Unsafe.As<RawArrayData>(array).Data);

src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/__Finalizer.cs

@@ -60,7 +60,7 @@ private static unsafe void DrainQueue()
                 // Call the finalizer on the current target object. If the finalizer throws we'll fail
                 // fast via normal Redhawk exception semantics (since we don't attempt to catch
                 // anything).
-                ((delegate*<object, void>)target.MethodTable->FinalizerCode)(target);
+                ((delegate*<object, void>)target.GetMethodTable()->FinalizerCode)(target);
             }
         }
     }

src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs

@@ -703,7 +703,7 @@ public static object CheckArgumentForDirectFieldAccess(object srcObject, Runtime
 
         public static bool IsAssignable(object srcObject, RuntimeTypeHandle dstType)
         {
-            EETypePtr srcEEType = srcObject.EETypePtr;
+            EETypePtr srcEEType = srcObject.GetEETypePtr();
             return RuntimeImports.AreTypesAssignable(srcEEType, dstType.ToEETypePtr());
         }
 
@@ -851,7 +851,7 @@ public static void ReportUnhandledException(Exception exception)
 
         public static unsafe RuntimeTypeHandle GetRuntimeTypeHandleFromObjectReference(object obj)
         {
-            return new RuntimeTypeHandle(obj.EETypePtr);
+            return new RuntimeTypeHandle(obj.GetEETypePtr());
         }
 
         // Move memory which may be on the heap which may have object references in it.