Implement RuntimeHelpers.SizeOf

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

@@ -416,6 +416,23 @@ private static unsafe void DispatchTailCalls(
                 }
             }
         }
+
+        [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_SizeOf")]
+        private static partial int SizeOf(QCallTypeHandle handle);
+
+        public static int SizeOf(RuntimeTypeHandle type)
+        {
+            RuntimeTypeHandle typeLocal = type;
+            if (typeLocal.IsNullHandle())
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.type);
+
+            int result = SizeOf(new QCallTypeHandle(ref typeLocal));
+
+            if (result < 0)
+                throw new ArgumentException(SR.Arg_TypeNotSupported);
+
+            return result;
+        }
     }
     // Helper class to assist with unsafe pinning of arbitrary objects.
     // It's used by VM code.

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.NativeAot.cs

@@ -361,6 +361,22 @@ public static unsafe object GetUninitializedObject(
 
             return RuntimeImports.RhNewObject(mt);
         }
+
+        public static unsafe int SizeOf(RuntimeTypeHandle type)
+        {
+            RuntimeTypeHandle typeLocal = type;
+            if (typeLocal.IsNull)
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.type);
+
+            MethodTable* mt = type.ToMethodTable();
+
+            if (mt->IsValueType)
+            {
+                return (int)mt->ValueTypeSize;
+            }
+
+            return nint.Size;
+        }
     }
 
     // CLR arrays are laid out in memory as follows (multidimensional array bounds are optional):

src/coreclr/vm/qcallentrypoints.cpp

@@ -337,6 +337,7 @@ static const Entry s_QCall[] =
     DllImportEntry(ReflectionInvocation_RunModuleConstructor)
     DllImportEntry(ReflectionInvocation_CompileMethod)
     DllImportEntry(ReflectionInvocation_PrepareMethod)
+    DllImportEntry(ReflectionInvocation_SizeOf)
     DllImportEntry(ReflectionSerialization_GetCreateUninitializedObjectInfo)
 #if defined(FEATURE_COMWRAPPERS)
     DllImportEntry(ComWrappers_GetIUnknownImpl)

src/coreclr/vm/reflectioninvocation.cpp

@@ -2120,3 +2120,18 @@ FCIMPL2_IV(Object*, ReflectionEnum::InternalBoxEnum, ReflectClassBaseObject* tar
     return OBJECTREFToObject(ret);
 }
 FCIMPLEND
+
+extern "C" int32_t QCALLTYPE ReflectionInvocation_SizeOf(QCall::TypeHandle pType)
+{
+    QCALL_CONTRACT;
+
+    int32_t size = 0;
+
+    BEGIN_QCALL;
+
+    size = pType.AsTypeHandle().GetSize();
+
+    END_QCALL;
+
+    return size;
+}

src/coreclr/vm/reflectioninvocation.h

@@ -82,4 +82,6 @@ class ReflectionEnum {
 
 extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames);
 
+extern "C" int32_t QCALLTYPE ReflectionInvocation_SizeOf(QCall::TypeHandle pType);
+
 #endif // _REFLECTIONINVOCATION_H_

src/libraries/System.Runtime/ref/System.Runtime.cs

@@ -13175,6 +13175,7 @@ public static void ProbeForSufficientStack() { }
         [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Trimmer can't guarantee existence of class constructor")]
         public static void RunClassConstructor(System.RuntimeTypeHandle type) { }
         public static void RunModuleConstructor(System.ModuleHandle module) { }
+        public static int SizeOf(System.RuntimeTypeHandle type) { throw null; }
         public static bool TryEnsureSufficientExecutionStack() { throw null; }
         public delegate void CleanupCode(object? userData, bool exceptionThrown);
         public delegate void TryCode(object? userData);

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/RuntimeHelpersTests.cs

@@ -437,6 +437,32 @@ public static void FixedAddressValueTypeTest()
 
             Assert.Equal(fixedPtr1, fixedPtr2);
         }
+
+        [InlineArray(4)]
+        private struct Byte4
+        {
+            public byte b1;
+        }
+
+        [Fact]
+        public static unsafe void SizeOf()
+        {
+            Assert.Equal(1, RuntimeHelpers.SizeOf(typeof(sbyte).TypeHandle));
+            Assert.Equal(1, RuntimeHelpers.SizeOf(typeof(byte).TypeHandle));
+            Assert.Equal(2, RuntimeHelpers.SizeOf(typeof(short).TypeHandle));
+            Assert.Equal(2, RuntimeHelpers.SizeOf(typeof(ushort).TypeHandle));
+            Assert.Equal(4, RuntimeHelpers.SizeOf(typeof(int).TypeHandle));
+            Assert.Equal(4, RuntimeHelpers.SizeOf(typeof(uint).TypeHandle));
+            Assert.Equal(8, RuntimeHelpers.SizeOf(typeof(long).TypeHandle));
+            Assert.Equal(8, RuntimeHelpers.SizeOf(typeof(ulong).TypeHandle));
+            Assert.Equal(4, RuntimeHelpers.SizeOf(typeof(float).TypeHandle));
+            Assert.Equal(8, RuntimeHelpers.SizeOf(typeof(double).TypeHandle));
+            Assert.Equal(4, RuntimeHelpers.SizeOf(typeof(Byte4).TypeHandle));
+            Assert.Equal(nint.Size, RuntimeHelpers.SizeOf(typeof(void*).TypeHandle));
+            Assert.Equal(nint.Size, RuntimeHelpers.SizeOf(typeof(delegate* <void>).TypeHandle));
+            Assert.Throws<ArgumentNullException>(() => RuntimeHelpers.SizeOf(default));
+            Assert.ThrowsAny<ArgumentException>(() => RuntimeHelpers.SizeOf(typeof(List<>).GetGenericArguments()[0].TypeHandle));
+        }
     }
 
     public struct Age

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

@@ -211,5 +211,20 @@ private static extern unsafe IntPtr GetSpanDataFrom(
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern bool SufficientExecutionStack();
+
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private static extern int SizeOf(QCallTypeHandle handle);
+
+        public static int SizeOf(RuntimeTypeHandle type)
+        {
+            RuntimeTypeHandle typeLocal = type;
+            if (typeLocal.Value == IntPtr.Zero)
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.type);
+
+            if (Type.GetTypeFromHandle(type)!.IsGenericParameter)
+                throw new ArgumentException(SR.Arg_TypeNotSupported);
+
+            return SizeOf(new QCallTypeHandle(ref typeLocal));
+        }
     }
 }

src/mono/mono/metadata/icall-def.h

@@ -439,6 +439,7 @@ HANDLES(RUNH_7, "InternalGetHashCode", ves_icall_System_Runtime_CompilerServices
 HANDLES(RUNH_3a, "PrepareMethod", ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_PrepareMethod, void, 3, (MonoMethod_ptr, gpointer, int))
 HANDLES(RUNH_4, "RunClassConstructor", ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor, void, 1, (MonoType_ptr))
 HANDLES(RUNH_5, "RunModuleConstructor", ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor, void, 1, (MonoImage_ptr))
+HANDLES(RUNH_9, "SizeOf", ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SizeOf, gint32, 1, (MonoQCallTypeHandle))
 NOHANDLES(ICALL(RUNH_5h, "SufficientExecutionStack", ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack))
 
 ICALL_TYPE(GCH, "System.Runtime.InteropServices.GCHandle", GCH_1)

src/mono/mono/metadata/icall.c

@@ -1210,6 +1210,13 @@ ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_PrepareMethod (MonoMeth
 	// FIXME: Implement
 }
 
+gint32
+ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SizeOf (MonoQCallTypeHandle type, MonoError* error)
+{
+	int align;
+	return mono_type_size (type.type, &align);
+}
+
 MonoObjectHandle
 ves_icall_System_Object_MemberwiseClone (MonoObjectHandle this_obj, MonoError *error)
 {