diff --git a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs index 6f578ccad411fd..cc46e2a75d8b2c 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs @@ -14,9 +14,6 @@ public abstract partial class Enum [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Enum_GetValuesAndNames")] private static partial void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames); - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern object InternalBoxEnum(RuntimeType enumType, long value); - [MethodImpl(MethodImplOptions.InternalCall)] private static extern unsafe CorElementType InternalGetCorElementType(MethodTable* pMT); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdConstant.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdConstant.cs index 498b6adf52e4aa..1ef9ed2e331741 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdConstant.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdConstant.cs @@ -72,7 +72,7 @@ internal static class MdConstant #endregion } - return RuntimeType.CreateEnum(fieldType, defaultValue); + return Enum.ToObject(fieldType, defaultValue); } else if (fieldType == typeof(DateTime)) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs index 6a1fae9e05c706..56ff2e26850ccc 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs @@ -3664,9 +3664,6 @@ public override Type MakeArrayType(int rank) [MethodImpl(MethodImplOptions.InternalCall)] private static extern bool CanValueSpecialCast(RuntimeType valueType, RuntimeType targetType); - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern object AllocateValueType(RuntimeType type, object? value); - private CheckValueStatus TryChangeTypeSpecial(ref object value) { Pointer? pointer = value as Pointer; @@ -3973,14 +3970,6 @@ internal object GetUninitializedObject() #region Legacy internal static - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern object _CreateEnum(RuntimeType enumType, long value); - - internal static object CreateEnum(RuntimeType enumType, long value) - { - return _CreateEnum(enumType, value); - } - #if FEATURE_COMINTEROP [MethodImpl(MethodImplOptions.InternalCall)] private extern object InvokeDispMethod( diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Enum.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Enum.NativeAot.cs index baf2e424546e4e..d9914ad15367f9 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Enum.NativeAot.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Enum.NativeAot.cs @@ -62,10 +62,8 @@ internal static EnumInfo GetEnumInfo(RuntimeType enumType, b } #pragma warning restore - private static unsafe object InternalBoxEnum(Type enumType, long value) - { - return ToObject(enumType.TypeHandle.ToMethodTable(), value); - } + internal static unsafe object ToObject(MethodTable* mt, long value) + => InternalBoxEnum(new RuntimeTypeHandle(mt), value); private static unsafe CorElementType InternalGetCorElementType(RuntimeType rt) { @@ -151,51 +149,5 @@ internal static Type InternalGetUnderlyingType(RuntimeType enumType) return GetEnumInfo(enumType).UnderlyingType; } - - [Conditional("BIGENDIAN")] - private static unsafe void AdjustForEndianness(ref byte* pValue, MethodTable* enumEEType) - { - // On Debug builds, include the big-endian code to help deter bitrot (the "Conditional("BIGENDIAN")" will prevent it from executing on little-endian). - // On Release builds, exclude code to deter IL bloat and toolchain work. -#if BIGENDIAN || DEBUG - EETypeElementType elementType = enumEEType->ElementType; - switch (elementType) - { - case EETypeElementType.SByte: - case EETypeElementType.Byte: - pValue += sizeof(long) - sizeof(byte); - break; - - case EETypeElementType.Int16: - case EETypeElementType.UInt16: - pValue += sizeof(long) - sizeof(short); - break; - - case EETypeElementType.Int32: - case EETypeElementType.UInt32: - pValue += sizeof(long) - sizeof(int); - break; - - case EETypeElementType.Int64: - case EETypeElementType.UInt64: - break; - - default: - throw new NotSupportedException(); - } -#endif //BIGENDIAN || DEBUG - } - - #region ToObject - - internal static unsafe object ToObject(MethodTable* enumEEType, long value) - { - Debug.Assert(enumEEType->IsEnum); - - byte* pValue = (byte*)&value; - AdjustForEndianness(ref pValue, enumEEType); - return RuntimeImports.RhBox(enumEEType, ref *pValue); - } - #endregion } } diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h index fa4f8cb485687d..dfcfbef6ba5826 100644 --- a/src/coreclr/vm/ecalllist.h +++ b/src/coreclr/vm/ecalllist.h @@ -56,7 +56,6 @@ FCFuncEnd() FCFuncStart(gEnumFuncs) FCFuncElement("InternalGetCorElementType", ReflectionEnum::InternalGetCorElementType) - FCFuncElement("InternalBoxEnum", ReflectionEnum::InternalBoxEnum) FCFuncEnd() FCFuncStart(gObjectFuncs) @@ -114,9 +113,7 @@ FCFuncEnd() FCFuncStart(gSystem_RuntimeType) FCFuncElement("GetGUID", ReflectionInvocation::GetGUID) - FCFuncElement("_CreateEnum", ReflectionInvocation::CreateEnum) FCFuncElement("CanValueSpecialCast", ReflectionInvocation::CanValueSpecialCast) - FCFuncElement("AllocateValueType", ReflectionInvocation::AllocateValueType) #if defined(FEATURE_COMINTEROP) FCFuncElement("InvokeDispMethod", ReflectionInvocation::InvokeDispMethod) #endif // defined(FEATURE_COMINTEROP) diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp index 65b7453f64c74b..4236724d37dd18 100644 --- a/src/coreclr/vm/reflectioninvocation.cpp +++ b/src/coreclr/vm/reflectioninvocation.cpp @@ -113,54 +113,6 @@ FCIMPL2(FC_BOOL_RET, ReflectionInvocation::CanValueSpecialCast, ReflectClassBase } FCIMPLEND -/// -/// Allocate the value type and copy the optional value into it. -/// -FCIMPL2(Object*, ReflectionInvocation::AllocateValueType, ReflectClassBaseObject *pTargetTypeUNSAFE, Object *valueUNSAFE) { - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(pTargetTypeUNSAFE)); - PRECONDITION(CheckPointer(valueUNSAFE, NULL_OK)); - } - CONTRACTL_END; - - struct _gc - { - REFLECTCLASSBASEREF refTargetType; - OBJECTREF value; - OBJECTREF obj; - }gc; - - gc.value = ObjectToOBJECTREF(valueUNSAFE); - gc.obj = gc.value; - gc.refTargetType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pTargetTypeUNSAFE); - - HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc); - - TypeHandle targetType = gc.refTargetType->GetType(); - - // This method is only intended for value types; it is not called directly by any public APIs - // so we don't expect validation issues here. - _ASSERTE(targetType.IsValueType()); - - MethodTable* allocMT = targetType.AsMethodTable(); - _ASSERTE(!allocMT->IsByRefLike()); - - gc.obj = allocMT->Allocate(); - _ASSERTE(gc.obj != NULL); - - if (gc.value != NULL) { - _ASSERTE(allocMT->IsEquivalentTo(gc.value->GetMethodTable())); - CopyValueClass(gc.obj->UnBox(), gc.value->UnBox(), allocMT); - } - - HELPER_METHOD_FRAME_END(); - - return OBJECTREFToObject(gc.obj); -} -FCIMPLEND - FCIMPL6(void, RuntimeFieldHandle::SetValue, ReflectFieldObject *pFieldUNSAFE, Object *targetUNSAFE, Object *valueUNSAFE, ReflectClassBaseObject *pFieldTypeUNSAFE, ReflectClassBaseObject *pDeclaringTypeUNSAFE, CLR_BOOL *pIsClassInitialized) { CONTRACTL { @@ -1535,24 +1487,6 @@ FCIMPL4(void, ReflectionInvocation::MakeTypedReference, TypedByRef * value, Obje } FCIMPLEND -FCIMPL2_IV(Object*, ReflectionInvocation::CreateEnum, ReflectClassBaseObject *pTypeUNSAFE, INT64 value) { - FCALL_CONTRACT; - - REFLECTCLASSBASEREF refType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pTypeUNSAFE); - - TypeHandle typeHandle = refType->GetType(); - _ASSERTE(typeHandle.IsEnum()); - OBJECTREF obj = NULL; - HELPER_METHOD_FRAME_BEGIN_RET_1(refType); - MethodTable *pEnumMT = typeHandle.AsMethodTable(); - obj = pEnumMT->Box(ArgSlotEndiannessFixup ((ARG_SLOT*)&value, - pEnumMT->GetNumInstanceFieldBytes())); - - HELPER_METHOD_FRAME_END(); - return OBJECTREFToObject(obj); -} -FCIMPLEND - #ifdef FEATURE_COMINTEROP FCIMPL8(Object*, ReflectionInvocation::InvokeDispMethod, ReflectClassBaseObject* refThisUNSAFE, StringObject* nameUNSAFE, @@ -1965,7 +1899,7 @@ extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectIn bool fHasSideEffectsUnused; *ppfnAllocator = CEEJitInfo::getHelperFtnStatic(CEEInfo::getNewHelperStatic(pMT, &fHasSideEffectsUnused)); *pvAllocatorFirstArg = pMT; - + pMT->EnsureInstanceActive(); if (pMT->HasPreciseInitCctors()) @@ -2105,22 +2039,6 @@ extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QC END_QCALL; } -FCIMPL2_IV(Object*, ReflectionEnum::InternalBoxEnum, ReflectClassBaseObject* target, INT64 value) { - FCALL_CONTRACT; - - VALIDATEOBJECT(target); - OBJECTREF ret = NULL; - - MethodTable* pMT = target->GetType().AsMethodTable(); - HELPER_METHOD_FRAME_BEGIN_RET_0(); - - ret = pMT->Box(ArgSlotEndiannessFixup((ARG_SLOT*)&value, pMT->GetNumInstanceFieldBytes())); - - HELPER_METHOD_FRAME_END(); - return OBJECTREFToObject(ret); -} -FCIMPLEND - extern "C" int32_t QCALLTYPE ReflectionInvocation_SizeOf(QCall::TypeHandle pType) { QCALL_CONTRACT_NO_GC_TRANSITION; diff --git a/src/coreclr/vm/reflectioninvocation.h b/src/coreclr/vm/reflectioninvocation.h index d84e40f3a93ebd..3bbf1d57bb1ed7 100644 --- a/src/coreclr/vm/reflectioninvocation.h +++ b/src/coreclr/vm/reflectioninvocation.h @@ -57,11 +57,9 @@ class ReflectionInvocation { static FCDECL8(Object*, InvokeDispMethod, ReflectClassBaseObject* refThisUNSAFE, StringObject* nameUNSAFE, INT32 invokeAttr, Object* targetUNSAFE, PTRArray* argsUNSAFE, PTRArray* byrefModifiersUNSAFE, LCID lcid, PTRArray* namedParametersUNSAFE); #endif // FEATURE_COMINTEROP static FCDECL2(void, GetGUID, ReflectClassBaseObject* refThisUNSAFE, GUID * result); - static FCDECL2_IV(Object*, CreateEnum, ReflectClassBaseObject *pTypeUNSAFE, INT64 value); // helper fcalls for invocation static FCDECL2(FC_BOOL_RET, CanValueSpecialCast, ReflectClassBaseObject *valueType, ReflectClassBaseObject *targetType); - static FCDECL2(Object*, AllocateValueType, ReflectClassBaseObject *targetType, Object *valueUNSAFE); }; extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD); @@ -77,7 +75,6 @@ extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectIn class ReflectionEnum { public: static FCDECL1(INT32, InternalGetCorElementType, MethodTable* pMT); - static FCDECL2_IV(Object*, InternalBoxEnum, ReflectClassBaseObject* pEnumType, INT64 value); }; extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames); diff --git a/src/libraries/System.Private.CoreLib/src/System/Enum.cs b/src/libraries/System.Private.CoreLib/src/System/Enum.cs index 7e9a94a83ed9db..20fd34bf70d89c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Enum.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Enum.cs @@ -12,6 +12,7 @@ using System.Numerics; using System.Reflection; using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; #pragma warning disable 8500 // Allow taking address of managed types @@ -768,7 +769,7 @@ private static unsafe bool TryParse(Type enumType, ReadOnlySpan value, boo break; } - result = parsed ? InternalBoxEnum(rt, longScratch) : null; + result = parsed ? InternalBoxEnum(rt.TypeHandle, longScratch) : null; return parsed; [MethodImpl(MethodImplOptions.NoInlining)] @@ -2225,31 +2226,47 @@ public static object ToObject(Type enumType, object value) [CLSCompliant(false)] public static object ToObject(Type enumType, sbyte value) => - InternalBoxEnum(ValidateRuntimeType(enumType), value); + InternalBoxEnum(ValidateRuntimeType(enumType).TypeHandle, value); public static object ToObject(Type enumType, short value) => - InternalBoxEnum(ValidateRuntimeType(enumType), value); + InternalBoxEnum(ValidateRuntimeType(enumType).TypeHandle, value); public static object ToObject(Type enumType, int value) => - InternalBoxEnum(ValidateRuntimeType(enumType), value); + InternalBoxEnum(ValidateRuntimeType(enumType).TypeHandle, value); public static object ToObject(Type enumType, byte value) => - InternalBoxEnum(ValidateRuntimeType(enumType), value); + InternalBoxEnum(ValidateRuntimeType(enumType).TypeHandle, value); [CLSCompliant(false)] public static object ToObject(Type enumType, ushort value) => - InternalBoxEnum(ValidateRuntimeType(enumType), value); + InternalBoxEnum(ValidateRuntimeType(enumType).TypeHandle, value); [CLSCompliant(false)] public static object ToObject(Type enumType, uint value) => - InternalBoxEnum(ValidateRuntimeType(enumType), value); + InternalBoxEnum(ValidateRuntimeType(enumType).TypeHandle, value); public static object ToObject(Type enumType, long value) => - InternalBoxEnum(ValidateRuntimeType(enumType), value); + InternalBoxEnum(ValidateRuntimeType(enumType).TypeHandle, value); [CLSCompliant(false)] public static object ToObject(Type enumType, ulong value) => - InternalBoxEnum(ValidateRuntimeType(enumType), unchecked((long)value)); + InternalBoxEnum(ValidateRuntimeType(enumType).TypeHandle, unchecked((long)value)); + + private static object InternalBoxEnum(RuntimeTypeHandle type, long value) + { + ReadOnlySpan rawData = MemoryMarshal.AsBytes(new ReadOnlySpan(ref value)); + // On little-endian systems, we can always use the pointer to the start of the scratch space + // as memory layout since the least-significant bit is at the lowest address. + // For big-endian systems, the least-significant bit is at the highest address, so we need to adjust + // our starting ref to the correct offset from the end of the scratch space to get the value to box. + if (!BitConverter.IsLittleEndian) + { + int size = RuntimeHelpers.SizeOf(type); + rawData = rawData.Slice(sizeof(long) - size); + } + + return RuntimeHelpers.Box(ref MemoryMarshal.GetReference(rawData), type)!; + } internal static bool AreSequentialFromZero(TStorage[] values) where TStorage : struct, INumber { diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/MethodBaseInvoker.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/MethodBaseInvoker.cs index 531a8ed9f8167c..6a1b94d508595c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Reflection/MethodBaseInvoker.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/MethodBaseInvoker.cs @@ -402,6 +402,7 @@ private static bool TryByRefFastPath(RuntimeType type, ref object arg) { if (sigElementType.IsValueType) { + Debug.Assert(!sigElementType.IsNullableOfT, "A true boxed Nullable should never be here."); // Make a copy to prevent the boxed instance from being directly modified by the method. arg = RuntimeType.AllocateValueType(sigElementType, arg); } diff --git a/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs b/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs index 17fbb2950c6c20..a4cfbaee8f29a9 100644 --- a/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs +++ b/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs @@ -881,6 +881,31 @@ internal bool CheckValue( return false; } + [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2067:UnrecognizedReflectionPattern", + Justification = "AllocateValueType is only called on a ValueType. You can always create an instance of a ValueType.")] + [return: NotNullIfNotNull(nameof(value))] + internal static object? AllocateValueType(RuntimeType type, object? value) + { + Debug.Assert(type.IsValueType); + Debug.Assert(!type.IsByRefLike); + + if (value is not null) + { + // Make a copy of the provided value by re-boxing the existing value's underlying data. + Debug.Assert(type.IsEquivalentTo(value.GetType())); + return RuntimeHelpers.Box(ref RuntimeHelpers.GetRawData(value), type.TypeHandle)!; + } + + if (type.IsNullableOfT) + { + // If the type is Nullable, then create a true boxed Nullable of the default Nullable value. + return RuntimeMethodHandle.ReboxToNullable(null, type); + } + + // Otherwise, just create a default instance of the type. + return RuntimeHelpers.GetUninitializedObject(type); + } + private CheckValueStatus TryChangeType(ref object? value, ref bool copyBack) { RuntimeType? sigElementType; diff --git a/src/mono/System.Private.CoreLib/src/System/Enum.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Enum.Mono.cs index c057acd9da07c4..5a4fe01cfc5d83 100644 --- a/src/mono/System.Private.CoreLib/src/System/Enum.Mono.cs +++ b/src/mono/System.Private.CoreLib/src/System/Enum.Mono.cs @@ -15,22 +15,12 @@ public partial class Enum [MethodImpl(MethodImplOptions.InternalCall)] private static extern void GetEnumValuesAndNames(QCallTypeHandle enumType, out ulong[] values, out string[] names); - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern void InternalBoxEnum(QCallTypeHandle enumType, ObjectHandleOnStack res, long value); - [MethodImpl(MethodImplOptions.InternalCall)] private static extern CorElementType InternalGetCorElementType(QCallTypeHandle enumType); [MethodImpl(MethodImplOptions.InternalCall)] private static extern void InternalGetUnderlyingType(QCallTypeHandle enumType, ObjectHandleOnStack res); - private static object InternalBoxEnum(RuntimeType enumType, long value) - { - object? res = null; - InternalBoxEnum(new QCallTypeHandle(ref enumType), ObjectHandleOnStack.Create(ref res), value); - return res!; - } - private static unsafe CorElementType InternalGetCorElementType(RuntimeType rt) { Debug.Assert(rt.IsActualEnum); diff --git a/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs b/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs index 62fb94c5a74175..f289911d790f39 100644 --- a/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs +++ b/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs @@ -2218,16 +2218,6 @@ public override string ToString() [MethodImplAttribute(MethodImplOptions.InternalCall)] private static extern object CreateInstanceInternal(QCallTypeHandle type); - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern void AllocateValueType(QCallTypeHandle type, object? value, ObjectHandleOnStack res); - - internal static object AllocateValueType(RuntimeType type, object? value) - { - object? res = null; - AllocateValueType(new QCallTypeHandle(ref type), value, ObjectHandleOnStack.Create(ref res)); - return res!; - } - [MethodImplAttribute(MethodImplOptions.InternalCall)] private static extern void GetDeclaringMethod(QCallTypeHandle type, ObjectHandleOnStack res); diff --git a/src/mono/mono/metadata/icall-def.h b/src/mono/mono/metadata/icall-def.h index f6b3b08cfc6188..53c95c8245faeb 100644 --- a/src/mono/mono/metadata/icall-def.h +++ b/src/mono/mono/metadata/icall-def.h @@ -194,9 +194,8 @@ NOHANDLES(ICALL(NATIVE_RUNTIME_EVENT_SOURCE_16, "LogWaitHandleWaitStop", ves_ica ICALL_TYPE(ENUM, "System.Enum", ENUM_1) HANDLES(ENUM_1, "GetEnumValuesAndNames", ves_icall_System_Enum_GetEnumValuesAndNames, void, 3, (MonoQCallTypeHandle, MonoArrayOut, MonoArrayOut)) -HANDLES(ENUM_2, "InternalBoxEnum", ves_icall_System_Enum_InternalBoxEnum, void, 3, (MonoQCallTypeHandle, MonoObjectHandleOnStack, guint64)) -NOHANDLES(ICALL(ENUM_3, "InternalGetCorElementType", ves_icall_System_Enum_InternalGetCorElementType)) -HANDLES(ENUM_4, "InternalGetUnderlyingType", ves_icall_System_Enum_InternalGetUnderlyingType, void, 2, (MonoQCallTypeHandle, MonoObjectHandleOnStack)) +NOHANDLES(ICALL(ENUM_2, "InternalGetCorElementType", ves_icall_System_Enum_InternalGetCorElementType)) +HANDLES(ENUM_3, "InternalGetUnderlyingType", ves_icall_System_Enum_InternalGetUnderlyingType, void, 2, (MonoQCallTypeHandle, MonoObjectHandleOnStack)) ICALL_TYPE(ENV, "System.Environment", ENV_1) NOHANDLES(ICALL(ENV_1, "Exit", ves_icall_System_Environment_Exit)) @@ -490,8 +489,7 @@ HANDLES(MHAN_1, "GetFunctionPointer", ves_icall_RuntimeMethodHandle_GetFunctionP HANDLES(MAHN_3, "ReboxFromNullable", ves_icall_RuntimeMethodHandle_ReboxFromNullable, void, 2, (MonoObject, MonoObjectHandleOnStack)) HANDLES(MAHN_2, "ReboxToNullable", ves_icall_RuntimeMethodHandle_ReboxToNullable, void, 3, (MonoObject, MonoQCallTypeHandle, MonoObjectHandleOnStack)) -ICALL_TYPE(RT, "System.RuntimeType", RT_31) -HANDLES(RT_31, "AllocateValueType", ves_icall_System_RuntimeType_AllocateValueType, void, 3, (MonoQCallTypeHandle, MonoObject, MonoObjectHandleOnStack)) +ICALL_TYPE(RT, "System.RuntimeType", RT_1) HANDLES(RT_1, "CreateInstanceInternal", ves_icall_System_RuntimeType_CreateInstanceInternal, MonoObject, 1, (MonoQCallTypeHandle)) HANDLES(RT_28, "FunctionPointerReturnAndParameterTypes", ves_icall_RuntimeType_FunctionPointerReturnAndParameterTypes, GPtrArray_ptr, 1, (MonoQCallTypeHandle)) NOHANDLES(ICALL(RT_33, "GetCallingConventionFromFunctionPointerInternal", ves_icall_RuntimeType_GetCallingConventionFromFunctionPointerInternal)) diff --git a/src/mono/mono/metadata/icall.c b/src/mono/mono/metadata/icall.c index 584c75c2c42157..2fbed9bbe44df4 100644 --- a/src/mono/mono/metadata/icall.c +++ b/src/mono/mono/metadata/icall.c @@ -3720,28 +3720,6 @@ write_enum_value (void *mem, int type, guint64 value) return; } -void -ves_icall_System_Enum_InternalBoxEnum (MonoQCallTypeHandle enum_handle, MonoObjectHandleOnStack res, guint64 value, MonoError *error) -{ - MonoClass *enumc; - MonoObjectHandle resultHandle; - MonoType *etype; - - enumc = mono_class_from_mono_type_internal (enum_handle.type); - - mono_class_init_checked (enumc, error); - return_if_nok (error); - - etype = mono_class_enum_basetype_internal (enumc); - - resultHandle = mono_object_new_handle (enumc, error); - return_if_nok (error); - - write_enum_value (mono_handle_unbox_unsafe (resultHandle), etype->type, value); - - HANDLE_ON_STACK_SET (res, MONO_HANDLE_RAW (resultHandle)); -} - void ves_icall_System_Enum_InternalGetUnderlyingType (MonoQCallTypeHandle type_handle, MonoObjectHandleOnStack res, MonoError *error) { @@ -6281,29 +6259,6 @@ ves_icall_System_RuntimeType_CreateInstanceInternal (MonoQCallTypeHandle type_ha return mono_object_new_handle (klass, error); } -/* Only used for value types */ -void -ves_icall_System_RuntimeType_AllocateValueType (MonoQCallTypeHandle type_handle, MonoObjectHandle value_h, MonoObjectHandleOnStack res, MonoError *error) -{ - MonoType *type = type_handle.type; - MonoClass *klass = mono_class_from_mono_type_internal (type); - - mono_class_init_checked (klass, error); - goto_if_nok (error, error_ret); - - MonoObject *obj_res = mono_object_new_checked (klass, error); - goto_if_nok (error, error_ret); - - MonoObject *value = MONO_HANDLE_RAW (value_h); - if (value) - mono_value_copy_internal (mono_object_unbox_internal (obj_res), mono_object_unbox_internal (value), klass); - - HANDLE_ON_STACK_SET (res, obj_res); - return; -error_ret: - HANDLE_ON_STACK_SET (res, NULL); -} - MonoReflectionMethodHandle ves_icall_RuntimeMethodInfo_get_base_method (MonoReflectionMethodHandle m, MonoBoolean definition, MonoError *error) {