Improve the performance of the type loader through various tweaks

docs/design/coreclr/botr/readytorun-format.md

@@ -179,6 +179,10 @@ The following section types are defined and described later in this document:
 | PgoInstrumentationData    |   117 | Image (added in V5.2)
 | ManifestAssemblyMvids     |   118 | Image (added in V5.3)
 | CrossModuleInlineInfo     |   119 | Image (added in V6.3)
+| HotColdMap                |   120 | Undocumented
+| MethodIsGenericMap        |   121 | Assembly (Added in V9.0)
+| EnclosingTypeMap          |   122 | Assembly (Added in V9.0)
+| TypeGenericInfoMap        |   123 | Assembly (Added in V9.0)
 
 ## ReadyToRunSectionType.CompilerIdentifier
 
@@ -644,6 +648,33 @@ The entry of the hashtable is a counted sequence of compressed unsigned integers
 
 This section may be included in addition to a InliningInfo2 section.
 
+## ReadyToRunSectionType.MethodIsGenericMap (v9.0+)
+This optional section holds a bit vector to indicate if the MethodDefs contained within the assembly have generic parameters or not. This allows determining if a method is generic or not by querying a bit vector (which is fast, and efficient) as opposed to examining the GenericParameter table, or the signature of the Method.
+
+The section begins with a single 32 bit integer indicating the number of bits in the bit vector. Following that integer is the actual bit vector of all of the data. The data is grouped into 8 bit bytes, where the least significant bit of the byte is the bit which represents the lowest MethodDef.
+
+For instance, the first byte in the bit vector represents the MethodDefs 06000001 to 06000008, and the least signficant bit of that first byte is the bit representing the IsGeneric bit for MethodDef 06000001.
+
+## ReadyToRunSectionType.EnclosingTypeMap (v9.0+)
+
+This optional section allows for efficient O(1) lookup from the enclosed type to the type which encloses it without requiring the binary search that is necessary if using the ECMA 335 defined NestedClass table (which encodes exactly the same information). This section may only be included in the assembly if the assembly has fewer than 0xFFFE types defined within it.
+
+The structure of this section is:
+A single 16 bit unsigned integer listing the count of entries in the map.
+This count is followed by a 16 bit unsigned integer for each TypeDef defined in the assembly. This typedef is the RID of the enclosing type, or 0 if the typedef is not enclosed by another type.
+
+## ReadyToRunSectionType.TypeGenericInfoMap (v9.0+)
+This optional section represents a condensed view of some generic details about types. This can make it more efficient to load types.
+
+The structure of this section is:
+A single 32 bit integer representing the number of entries in the map followed by a series of 4 bit entries, one per type. These 4 bit entries are grouped into bytes, where each byte holds 2 entries, and the entry in the most significant 4 bits of the byte is the entry representing a lower TypeDef RID.
+
+TypeGenericInfoMap entries have 4 bits representing 3 different sets of information.
+
+1. What is the count of generic parameters (0, 1, 2, MoreThanTwo) (This is represented in the least significant 2 bits of the TypeGenericInfoMap entry)
+2. Are there any constraints on the generic parameters? (This is the 3rd bit of the entry)
+3. Do any of the generic parameters have co or contra variance? (This is the 4th bit of the entry)
+
 # Native Format
 
 Native format is set of encoding patterns that allow persisting type system data in a binary format that is

src/coreclr/inc/readytorun.h

@@ -92,6 +92,9 @@ enum class ReadyToRunSectionType : uint32_t
     ManifestAssemblyMvids       = 118, // Added in V5.3
     CrossModuleInlineInfo       = 119, // Added in V6.2
     HotColdMap                  = 120, // Added in V8.0
+    MethodIsGenericMap          = 121, // Added in V9.0
+    EnclosingTypeMap               = 122, // Added in V9.0
+    TypeGenericInfoMap          = 123, // Added in V9.0
 
     // If you add a new section consider whether it is a breaking or non-breaking change.
     // Usually it is non-breaking, but if it is preferable to have older runtimes fail
@@ -121,6 +124,23 @@ enum class ReadyToRunImportSectionFlags : uint16_t
     PCode    = 0x0004, // Section contains pointers to code
 };
 
+// All values in this enum should within a nibble (4 bits).
+enum class ReadyToRunTypeGenericInfo : uint8_t
+{
+    GenericCountMask = 0x3,
+    HasConstraints = 0x4,
+    HasVariance = 0x8,
+};
+
+// All values in this enum should fit within 2 bits.
+enum class ReadyToRunGenericInfoGenericCount : uint32_t
+{
+    Zero = 0,
+    One = 1,
+    Two = 2,
+    MoreThanTwo = 3
+};
+
 //
 // READYTORUN_IMPORT_SECTION describes image range with references to code or runtime data structures
 //

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/TypeSystem/RuntimeGenericParameterDesc.cs

@@ -9,6 +9,7 @@ internal class RuntimeGenericParameterDesc : GenericParameterDesc
         private readonly int _index;
         private readonly TypeSystemContext _context;
         private readonly GenericVariance _variance;
+        private TypeSystemEntity _associatedTypeOrMethod;
 
         public RuntimeGenericParameterDesc(GenericParameterKind kind, int index, TypeSystemContext context, GenericVariance variance)
         {
@@ -25,5 +26,12 @@ public RuntimeGenericParameterDesc(GenericParameterKind kind, int index, TypeSys
         public override TypeSystemContext Context => _context;
 
         public override GenericVariance Variance => _variance;
+
+        public override TypeSystemEntity AssociatedTypeOrMethod => _associatedTypeOrMethod;
+
+        internal void SetAssociatedTypeOrMethod(TypeSystemEntity associatedTypeOrMethod)
+        {
+            _associatedTypeOrMethod = associatedTypeOrMethod;
+        }
     }
 }

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/TypeSystem/RuntimeMethodDesc.cs

@@ -52,7 +52,9 @@ public override Instantiation Instantiation
                         TypeDesc[] genericParameters = new TypeDesc[genericArgCount];
                         for (int i = 0; i < genericParameters.Length; i++)
                         {
-                            genericParameters[i] = new RuntimeGenericParameterDesc(GenericParameterKind.Method, i, Context, GenericVariance.None);
+                            var newGenericParameter = new RuntimeGenericParameterDesc(GenericParameterKind.Method, i, Context, GenericVariance.None);
+                            newGenericParameter.SetAssociatedTypeOrMethod(this);
+                            genericParameters[i] = newGenericParameter;
                         }
                         _instantiation = new Instantiation(genericParameters);
                     }

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/TypeSystem/TypeSystemContext.Runtime.cs

@@ -213,6 +213,10 @@ public TypeDesc ResolveRuntimeTypeHandle(RuntimeTypeHandle rtth)
                     }
 
                     returnedType = new NoMetadataType(this, rtth, null, new Instantiation(genericParameters), rtth.GetHashCode());
+                    for (int i = 0; i < genericParameters.Length; i++)
+                    {
+                        ((RuntimeGenericParameterDesc)genericParameters[i]).SetAssociatedTypeOrMethod(returnedType);
+                    }
                 }
             }
             else if (RuntimeAugments.IsGenericType(rtth))

src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs

@@ -71,6 +71,9 @@ public enum ReadyToRunSectionType
         ManifestAssemblyMvids = 118, // Added in 5.3
         CrossModuleInlineInfo = 119, // Added in 6.3
         HotColdMap = 120, // Added in 8.0
+        MethodIsGenericMap = 121, // Added in V9.0
+        EnclosingTypeMap = 122, // Added in V9.0
+        TypeGenericInfoMap = 123, // Added in V9.0
 
         //
         // NativeAOT ReadyToRun sections

src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs

@@ -12,8 +12,8 @@ namespace Internal.ReadyToRunConstants
     public enum ReadyToRunFlags
     {
         READYTORUN_FLAG_PlatformNeutralSource = 0x00000001,     // Set if the original IL assembly was platform-neutral
-        READYTORUN_FLAG_SkipTypeValidation = 0x00000002,        // Set of methods with native code was determined using profile data
-        READYTORUN_FLAG_Partial = 0x00000004,
+        READYTORUN_FLAG_SkipTypeValidation = 0x00000002,        // Runtime should trust that the metadata for the types defined in this module is correct
+        READYTORUN_FLAG_Partial = 0x00000004,                   // Set of methods with native code was determined using profile data
         READYTORUN_FLAG_NonSharedPInvokeStubs = 0x00000008,     // PInvoke stubs compiled into image are non-shareable (no secret parameter)
         READYTORUN_FLAG_EmbeddedMSIL = 0x00000010,              // MSIL is embedded in the composite R2R executable
         READYTORUN_FLAG_Component = 0x00000020,                 // This is the header describing a component assembly of composite R2R
@@ -89,6 +89,22 @@ internal enum ReadyToRunCrossModuleInlineFlags : uint
         InlinerRidShift = 1,
     };
 
+    [Flags]
+    public enum ReadyToRunTypeGenericInfo : byte
+    {
+        GenericCountMask = 0x3,
+        HasConstraints = 0x4,
+        HasVariance = 0x8,
+    }
+
+    public enum ReadyToRunGenericInfoGenericCount : uint
+    {
+        Zero = 0,
+        One = 1,
+        Two = 2,
+        MoreThanTwo = 3
+    }
+
     public enum DictionaryEntryKind
     {
         EmptySlot = 0,

src/coreclr/tools/Common/TypeSystem/Common/CastingHelper.cs

@@ -195,9 +195,21 @@ private static bool CanCastGenericParameterTo(this GenericParameterDesc thisType
                 return true;
             }
 
+            Instantiation typeInstantiation;
+            Instantiation methodInstantiation = default(Instantiation);
+            if (thisType.AssociatedTypeOrMethod is MethodDesc method)
+            {
+                typeInstantiation = method.OwningType.Instantiation;
+                methodInstantiation = method.Instantiation;
+            }
+            else
+            {
+                typeInstantiation = ((TypeDesc)thisType.AssociatedTypeOrMethod).Instantiation;
+            }
             foreach (var typeConstraint in thisType.TypeConstraints)
             {
-                if (typeConstraint.CanCastToInternal(otherType, protect))
+                TypeDesc instantiatedConstraint = typeConstraint.InstantiateSignature(typeInstantiation, methodInstantiation);
+                if (instantiatedConstraint.CanCastToInternal(otherType, protect))
                 {
                     return true;
                 }

src/coreclr/tools/Common/TypeSystem/Common/GenericParameterDesc.cs

@@ -87,6 +87,11 @@ public virtual string Name
         /// </summary>
         public abstract int Index { get; }
 
+        /// <summary>
+        /// The associated type or method which defines this Generic Parameter
+        /// </summary>
+        public abstract TypeSystemEntity AssociatedTypeOrMethod { get; }
+
         /// <summary>
         /// Gets a value indicating the variance of this generic parameter.
         /// </summary>
@@ -120,6 +125,9 @@ public virtual IEnumerable<TypeDesc> TypeConstraints
             }
         }
 
+        /// <summary>
+        /// Does this generic parameter have the NotNullableValueType constraint flag
+        /// </summary>
         public bool HasNotNullableValueTypeConstraint
         {
             get
@@ -128,6 +136,9 @@ public bool HasNotNullableValueTypeConstraint
             }
         }
 
+        /// <summary>
+        /// Does this generic parameter have the ReferenceType constraint flag
+        /// </summary>
         public bool HasReferenceTypeConstraint
         {
             get
@@ -136,6 +147,9 @@ public bool HasReferenceTypeConstraint
             }
         }
 
+        /// <summary>
+        /// Does this generic parameter have the DefaultConstructor constraint flag
+        /// </summary>
         public bool HasDefaultConstructorConstraint
         {
             get
@@ -144,6 +158,20 @@ public bool HasDefaultConstructorConstraint
             }
         }
 
+        /// <summary>
+        /// Does this generic parameter have the AcceptByRefLike flag
+        /// </summary>
+        public bool HasAcceptByRefLikeConstraint
+        {
+            get
+            {
+                return (Constraints & GenericConstraints.AcceptByRefLike) != 0;
+            }
+        }
+
+        /// <summary>
+        /// Is this generic parameter Covariant
+        /// </summary>
         public bool IsCovariant
         {
             get
@@ -152,6 +180,9 @@ public bool IsCovariant
             }
         }
 
+        /// <summary>
+        /// Is this generic parameter Contravariant
+        /// </summary>
         public bool IsContravariant
         {
             get

src/coreclr/tools/Common/TypeSystem/Common/SignatureVariable.cs

@@ -66,6 +66,10 @@ protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
                 flags |= TypeFlags.SignatureTypeVariable;
             }
 
+            flags |= TypeFlags.HasGenericVarianceComputed;
+            flags |= TypeFlags.HasFinalizerComputed;
+            flags |= TypeFlags.AttributeCacheComputed;
+
             return flags;
         }
 

src/coreclr/tools/Common/TypeSystem/Ecma/EcmaGenericParameter.cs

@@ -3,7 +3,7 @@
 
 using System.Collections.Generic;
 using System.Reflection.Metadata;
-
+using System.Threading;
 using Debug = System.Diagnostics.Debug;
 using GenericParameterAttributes = System.Reflection.GenericParameterAttributes;
 
@@ -13,6 +13,7 @@ public sealed partial class EcmaGenericParameter : GenericParameterDesc
     {
         private EcmaModule _module;
         private GenericParameterHandle _handle;
+        private TypeSystemEntity _associatedTypeOrMethod;
 
         internal EcmaGenericParameter(EcmaModule module, GenericParameterHandle handle)
         {
@@ -78,6 +79,22 @@ public override GenericParameterKind Kind
             }
         }
 
+        public override TypeSystemEntity AssociatedTypeOrMethod
+        {
+            get
+            {
+                TypeSystemEntity tse = Volatile.Read(ref _associatedTypeOrMethod);
+                if (tse == null)
+                {
+                    GenericParameter parameter = _module.MetadataReader.GetGenericParameter(_handle);
+
+                    tse = (TypeSystemEntity)_module.GetObject(parameter.Parent);
+                    Volatile.Write(ref _associatedTypeOrMethod, tse);
+                }
+                return tse;
+            }
+        }
+
         public override int Index
         {
             get

src/coreclr/tools/ILVerification/InstantiatedGenericParameter.cs

@@ -76,6 +76,8 @@ private InstantiatedGenericParameter(GenericParameterDesc genericParam)
 
         public override GenericConstraints Constraints => _genericParam.Constraints;
 
+        public override TypeSystemEntity AssociatedTypeOrMethod => _genericParam.AssociatedTypeOrMethod;
+
         public override IEnumerable<TypeDesc> TypeConstraints
         {
             get

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/EnclosingTypeMapNode.cs

@@ -0,0 +1,71 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+using Internal.Text;
+using Internal.TypeSystem.Ecma;
+using System.Diagnostics;
+using System.Reflection;
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
+using Internal.ReadyToRunConstants;
+
+namespace ILCompiler.DependencyAnalysis.ReadyToRun
+{
+    public class EnclosingTypeMapNode : ModuleSpecificHeaderTableNode
+    {
+        private MetadataReader _metadata;
+
+        public EnclosingTypeMapNode(EcmaModule module) : base(module)
+        {
+            _metadata = module.MetadataReader;
+            // This map is only valid for assemblies with <= 0xFFFE types defined within
+            if (!IsSupported(_metadata))
+                throw new InternalCompilerErrorException("EnclosingTypeMap made for assembly with more than 0xFFFE types");
+        }
+
+        public static bool IsSupported(MetadataReader metadata)
+        {
+            // This map is only valid for assemblies with <= 0xFFFE types defined within
+            // and really shouldn't be generated for tiny assemblies, as the map provides very little to no value
+            // in those situations
+            int typeDefinitionCount = metadata.TypeDefinitions.Count;
+
+            return ((typeDefinitionCount > 10) && (typeDefinitionCount <= 0xFFFE));
+        }
+
+        public override int ClassCode => 990540812;
+
+        protected override string ModuleSpecificName => "__EnclosingTypeMap__";
+
+        public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
+        {
+            // This node does not trigger generation of other nodes.
+            if (relocsOnly)
+                return new ObjectData(Array.Empty<byte>(), Array.Empty<Relocation>(), 1, new ISymbolDefinitionNode[] { this });
+
+            ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
+            builder.AddSymbol(this);
+
+            // This map is only valid for assemblies with <= 0xFFFE types defined within
+            Debug.Assert(_metadata.TypeDefinitions.Count <= 0xFFFE);
+            builder.EmitUShort(checked((ushort)_metadata.TypeDefinitions.Count));
+
+            foreach (var typeDefinitionHandle in _metadata.TypeDefinitions)
+            {
+                var typeDefinition = _metadata.GetTypeDefinition(typeDefinitionHandle);
+                if (!typeDefinition.IsNested)
+                {
+                    builder.EmitUShort(0);
+                }
+                else
+                {
+                    builder.EmitUShort(checked((ushort)MetadataTokens.GetRowNumber(typeDefinition.GetDeclaringType())));
+                }
+            }
+
+            return builder.ToObjectData();
+        }
+    }
+}