Improve performance of Activator.CreateInstance

src/coreclr/src/System.Private.CoreLib/src/System/Collections/Generic/ArraySortHelper.CoreCLR.cs

@@ -27,7 +27,7 @@ private static IArraySortHelper<T> CreateArraySortHelper()
 
             if (typeof(IComparable<T>).IsAssignableFrom(typeof(T)))
             {
-                defaultArraySortHelper = (IArraySortHelper<T>)RuntimeTypeHandle.Allocate(typeof(GenericArraySortHelper<string>).TypeHandle.Instantiate(new Type[] { typeof(T) }));
+                defaultArraySortHelper = (IArraySortHelper<T>)typeof(GenericArraySortHelper<string>).TypeHandle.Instantiate(new Type[] { typeof(T) }).CreateInstanceDefaultCtor(publicOnly: false, wrapExceptions: false)!;
             }
             else
             {
@@ -62,7 +62,7 @@ private static IArraySortHelper<TKey, TValue> CreateArraySortHelper()
 
             if (typeof(IComparable<TKey>).IsAssignableFrom(typeof(TKey)))
             {
-                defaultArraySortHelper = (IArraySortHelper<TKey, TValue>)RuntimeTypeHandle.Allocate(typeof(GenericArraySortHelper<string, string>).TypeHandle.Instantiate(new Type[] { typeof(TKey), typeof(TValue) }));
+                defaultArraySortHelper = (IArraySortHelper<TKey, TValue>)typeof(GenericArraySortHelper<string, string>).TypeHandle.Instantiate(new Type[] { typeof(TKey), typeof(TValue) }).CreateInstanceDefaultCtor(publicOnly: false, wrapExceptions: false)!;
             }
             else
             {

src/coreclr/src/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs

@@ -1228,7 +1228,7 @@ private static void AddCustomAttributes(
                 }
                 else
                 {
-                    attribute = attributeType.CreateInstanceDefaultCtor(publicOnly: false, skipCheckThis: true, fillCache: true, wrapExceptions: false)!;
+                    attribute = attributeType.CreateInstanceDefaultCtor(publicOnly: false, wrapExceptions: false)!;
 
                     // It is allowed by the ECMA spec to have an empty signature blob
                     int blobLen = (int)((byte*)blobEnd - (byte*)blobStart);

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

@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
 using System.Runtime.InteropServices;
 using Internal.Runtime.CompilerServices;
 
@@ -135,15 +136,23 @@ public static int OffsetToStringData
         [MethodImpl(MethodImplOptions.InternalCall)]
         public static extern bool TryEnsureSufficientExecutionStack();
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern object GetUninitializedObjectInternal(
-            // This API doesn't call any constructors, but the type needs to be seen as constructed.
-            // A type is seen as constructed if a constructor is kept.
-            // This obviously won't cover a type with no constructor. Reference types with no
-            // constructor are an academic problem. Valuetypes with no constructors are a problem,
-            // but IL Linker currently treats them as always implicitly boxed.
+        private static unsafe object GetUninitializedObjectInternal(
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            Type type);
+            Type type)
+        {
+            RuntimeType rt = (RuntimeType)type;
+            Debug.Assert(rt != null);
+
+            // If type is Nullable<T>, get newobj for boxed T instead.
+            delegate*<MethodTable*, object> newobjHelper = RuntimeTypeHandle.GetNewobjHelperFnPtr(rt, out MethodTable* pMT, unwrapNullable: true);
+            Debug.Assert(newobjHelper != null);
+            Debug.Assert(pMT != null);
+
+            object retVal = newobjHelper(pMT);
+            GC.KeepAlive(rt); // don't allow the type to be collected before the object is instantiated
+
+            return retVal;
+        }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal static extern object AllocateUninitializedClone(object obj);
@@ -378,10 +387,16 @@ internal unsafe struct MethodTable
         [FieldOffset(InterfaceMapOffset)]
         public MethodTable** InterfaceMap;
 
-        // WFLAGS_HIGH_ENUM
+        // WFLAGS_HIGH_ENUM & WFLAGS_LOW_ENUM
+        private const uint enum_flag_Category_Mask = 0x000F0000;
+        private const uint enum_flag_Category_Nullable = 0x00050000;
+        private const uint enum_flag_Category_ValueType = 0x00040000;
+        private const uint enum_flag_Category_ValueType_Mask = 0x000C0000;
         private const uint enum_flag_ContainsPointers = 0x01000000;
+        private const uint enum_flag_ComObject = 0x40000000;
         private const uint enum_flag_HasComponentSize = 0x80000000;
-        private const uint enum_flag_HasTypeEquivalence = 0x00004000;
+        private const uint enum_flag_HasDefaultCtor = 0x00000200;
+        private const uint enum_flag_HasTypeEquivalence = 0x00004000; // TODO: shouldn't this be 0x02000000?
         // Types that require non-trivial interface cast have this bit set in the category
         private const uint enum_flag_NonTrivialInterfaceCast = 0x00080000 // enum_flag_Category_Array
                                                              | 0x40000000 // enum_flag_ComObject
@@ -438,6 +453,38 @@ public bool NonTrivialInterfaceCast
             }
         }
 
+        public bool HasDefaultConstructor
+        {
+            get
+            {
+                return (Flags & enum_flag_HasDefaultCtor) != 0;
+            }
+        }
+
+        public bool IsComObject
+        {
+            get
+            {
+                return (Flags & enum_flag_ComObject) != 0;
+            }
+        }
+
+        public bool IsNullable
+        {
+            get
+            {
+                return (Flags & enum_flag_Category_Mask) == enum_flag_Category_Nullable;
+            }
+        }
+
+        public bool IsValueType
+        {
+            get
+            {
+                return (Flags & enum_flag_Category_ValueType_Mask) == enum_flag_Category_ValueType;
+            }
+        }
+
         public bool HasTypeEquivalence
         {
             get

src/coreclr/src/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs

@@ -200,7 +200,7 @@ private static void PrelinkCore(MethodInfo m)
         private static object PtrToStructureHelper(IntPtr ptr, Type structureType)
         {
             var rt = (RuntimeType)structureType;
-            object structure = rt.CreateInstanceDefaultCtor(publicOnly: false, skipCheckThis: false, fillCache: false, wrapExceptions: true)!;
+            object structure = rt.CreateInstanceDefaultCtor(publicOnly: false, wrapExceptions: true)!;
             PtrToStructureHelper(ptr, structure, allowValueClasses: true);
             return structure;
         }

src/coreclr/src/System.Private.CoreLib/src/System/RuntimeHandles.cs

@@ -205,6 +205,56 @@ internal static bool HasElementType(RuntimeType type)
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal static extern object CreateInstanceForAnotherGenericParameter(RuntimeType type, RuntimeType genericParameter);
 
+        /// <summary>
+        /// Given a RuntimeType, returns both the address of the JIT's newobj helper for that type and the
+        /// MethodTable* corresponding to that type. If the type is <see cref="Nullable{T}"/> closed over
+        /// some T, then returns the newobj helper and MethodTable* for the 'T'.
+        /// Return value signature is managed calli (MethodTable* pMT) -> object.
+        /// </summary>
+        internal static delegate*<MethodTable*, object> GetNewobjHelperFnPtr(
+            // This API doesn't call any constructors, but the type needs to be seen as constructed.
+            // A type is seen as constructed if a constructor is kept.
+            // This obviously won't cover a type with no constructor. Reference types with no
+            // constructor are an academic problem. Valuetypes with no constructors are a problem,
+            // but IL Linker currently treats them as always implicitly boxed.
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] RuntimeType type,
+            out MethodTable* pMT, bool unwrapNullable)
+        {
+            Debug.Assert(type != null);
+
+            delegate*<MethodTable*, object> pNewobjHelperTemp = null;
+            MethodTable* pMTTemp = null;
+
+            GetNewobjHelperFnPtr(
+                new QCallTypeHandle(ref type),
+                &pNewobjHelperTemp,
+                &pMTTemp,
+                unwrapNullable ? Interop.BOOL.TRUE : Interop.BOOL.FALSE);
+
+            pMT = pMTTemp;
+            return pNewobjHelperTemp;
+        }
+
+        [DllImport(RuntimeHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern void GetNewobjHelperFnPtr(QCallTypeHandle typeHandle, delegate*<MethodTable*, object>* ppNewobjHelper, MethodTable** ppMT, Interop.BOOL fUnwrapNullable);
+
+        /// <summary>
+        /// Returns the MethodDesc* for this type's parameterless instance ctor.
+        /// For reference types, signature is (object @this) -> void.
+        /// For value types, signature is (ref T @thisUnboxed) -> void.
+        /// Returns nullptr if no parameterless ctor is defined.
+        /// </summary>
+        internal static RuntimeMethodHandleInternal GetDefaultConstructor(
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] RuntimeType type)
+        {
+            Debug.Assert(type != null);
+
+            return GetDefaultCtor(new QCallTypeHandle(ref type));
+        }
+
+        [DllImport(RuntimeHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern RuntimeMethodHandleInternal GetDefaultCtor(QCallTypeHandle typeHandle);
+
         internal RuntimeType GetRuntimeType()
         {
             return m_type;