Improve the performance of the type loader through various tweaks

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,21 @@ enum class ReadyToRunImportSectionFlags : uint16_t
     PCode    = 0x0004, // Section contains pointers to code
 };
 
+enum class ReadyToRunTypeGenericInfo : uint8_t
+{
+    GenericCountMask = 0x3,
+    HasConstraints = 0x4,
+    HasVariance = 0x8,
+};
+
+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/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,23 @@ 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,19 @@ private static bool CanCastGenericParameterTo(this GenericParameterDesc thisType
                 return true;
             }
 
+            InstantiationContext context;
+            if (thisType.AssociatedTypeOrMethod is MethodDesc method)
+            {
+                context = new InstantiationContext(method.OwningType.Instantiation, method.Instantiation);
+            }
+            else
+            {
+                context = new InstantiationContext(((TypeDesc)thisType.AssociatedTypeOrMethod).Instantiation, default(Instantiation));
+            }
             foreach (var typeConstraint in thisType.TypeConstraints)
             {
-                if (typeConstraint.CanCastToInternal(otherType, protect))
+                TypeDesc instantiatedConstraint = typeConstraint.InstantiateSignature(context.TypeInstantiation, context.MethodInstantiation);
+                if (instantiatedConstraint.CanCastToInternal(otherType, protect))
                 {
                     return true;
                 }

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

@@ -87,6 +87,12 @@ 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>

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/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/EnclosingTypeMapNode.cs

@@ -0,0 +1,70 @@
+// 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
+            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();
+        }
+    }
+}

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

@@ -7,8 +7,10 @@
 using Internal.Runtime;
 using Internal.Text;
 using Internal.TypeSystem;
+using Internal.TypeSystem.Ecma;
 using Internal.ReadyToRunConstants;
 using ILCompiler.DependencyAnalysisFramework;
+using System.Threading.Tasks;
 
 namespace ILCompiler.DependencyAnalysis.ReadyToRun
 {
@@ -33,6 +35,50 @@ public override ObjectNodeSection GetSection(NodeFactory factory)
         }
     }
 
+    public abstract class ModuleSpecificHeaderTableNode : HeaderTableNode
+    {
+        protected readonly EcmaModule _module;
+
+        public ModuleSpecificHeaderTableNode(EcmaModule module)
+        {
+            _module = module;
+        }
+
+        public sealed override int CompareToImpl(ISortableNode other, CompilerComparer comparer)
+        {
+            ModuleSpecificHeaderTableNode otherModuleSpecificHeaderTableNode = (ModuleSpecificHeaderTableNode)other;
+
+            if (_module == null)
+            {
+                Debug.Assert(otherModuleSpecificHeaderTableNode._module != null);
+                return -1;
+            }
+            else if (otherModuleSpecificHeaderTableNode._module == null)
+            {
+                return 1;
+            }
+
+            return _module.Assembly.GetName().Name.CompareTo(otherModuleSpecificHeaderTableNode._module.Assembly.GetName().Name);
+        }
+
+        protected abstract string ModuleSpecificName { get; }
+
+        public sealed override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
+        {
+            sb.Append(nameMangler.CompilationUnitPrefix);
+            if (_module != null)
+            {
+                sb.Append(ModuleSpecificName);
+                sb.Append(_module.Assembly.GetName().Name);
+            }
+            else
+            {
+                sb.Append(ModuleSpecificName);
+            }
+
+        }
+    }
+
     public abstract class HeaderNode : ObjectNode, ISymbolDefinitionNode
     {
         struct HeaderItem
@@ -51,9 +97,19 @@ public HeaderItem(ReadyToRunSectionType id, DependencyNodeCore<NodeFactory> node
 
         private readonly List<HeaderItem> _items = new List<HeaderItem>();
         private readonly ReadyToRunFlags _flags;
+        private readonly Task<(bool canSkipValidation, string[] reasons)> _shouldAddSkipTypeValidationFlag;
 
-        public HeaderNode(ReadyToRunFlags flags)
+        public HeaderNode(ReadyToRunFlags flags, EcmaModule moduleToCheckForSkipTypeValidation)
         {
+
+            if (moduleToCheckForSkipTypeValidation != null)
+            {
+                _shouldAddSkipTypeValidationFlag = TypeValidationChecker.CanSkipValidation(moduleToCheckForSkipTypeValidation);
+            }
+            else
+            {
+                _shouldAddSkipTypeValidationFlag = Task.FromResult((false, new string[0]));
+            }
             _flags = flags;
         }
 
@@ -94,7 +150,19 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
                 _items.MergeSort((x, y) => Comparer<int>.Default.Compare((int)x.Id, (int)y.Id));
 
             // ReadyToRunHeader.Flags
-            builder.EmitInt((int)_flags);
+            int flagsInt = (int)_flags;
+            if (_shouldAddSkipTypeValidationFlag.Result.canSkipValidation)
+            {
+                flagsInt |= (int)ReadyToRunFlags.READYTORUN_FLAG_SkipTypeValidation;
+            }
+            else
+            {
+//#if DIAGNOSE_TYPE_VALIDATION_RULES
+//                foreach (string reason in _shouldAddSkipTypeValidationFlag.Result.reasons)
+//                    System.Console.WriteLine(reason);
+//#endif
+            }
+            builder.EmitInt(flagsInt);
 
             // ReadyToRunHeader.NumberOfSections
             ObjectDataBuilder.Reservation sectionCountReservation = builder.ReserveInt();
@@ -137,8 +205,8 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
 
     public class GlobalHeaderNode : HeaderNode
     {
-        public GlobalHeaderNode(ReadyToRunFlags flags)
-            : base(flags)
+        public GlobalHeaderNode(ReadyToRunFlags flags, EcmaModule moduleToCheckForSkipValidation)
+            : base(flags, moduleToCheckForSkipValidation)
         {
         }
 
@@ -166,7 +234,7 @@ public class AssemblyHeaderNode : HeaderNode
         private readonly int _index;
 
         public AssemblyHeaderNode(ReadyToRunFlags flags, int index)
-            : base(flags)
+            : base(flags, null)
         {
             _index = index;
         }