Delete vestiges of universal shared code support (#113640)

Author: MichalStrehovsky

src/coreclr/nativeaot/System.Private.CoreLib/src/CompatibilitySuppressions.xml

@@ -697,10 +697,6 @@
     <DiagnosticId>CP0001</DiagnosticId>
     <Target>T:Internal.Runtime.Augments.TypeLoaderCallbacks</Target>
   </Suppression>
-  <Suppression>
-    <DiagnosticId>CP0001</DiagnosticId>
-    <Target>T:Internal.Runtime.CanonTypeKind</Target>
-  </Suppression>
   <Suppression>
     <DiagnosticId>CP0001</DiagnosticId>
     <Target>T:Internal.Runtime.CompilerServices.FunctionPointerOps</Target>

src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs

@@ -483,7 +483,7 @@ public static IntPtr NewInterfaceDispatchCell(RuntimeTypeHandle interfaceTypeHan
         }
 
         [Intrinsic]
-        public static RuntimeTypeHandle GetCanonType(CanonTypeKind kind)
+        public static RuntimeTypeHandle GetCanonType()
         {
             // Compiler needs to expand this. This is not expressible in IL.
             throw new NotSupportedException();

src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj

@@ -353,9 +353,6 @@
     <Compile Include="$(CompilerCommonPath)\Internal\LowLevelLinq\LowLevelEnumerable.ToArray.cs">
       <Link>Internal\LowLevelLinq\LowLevelEnumerable.ToArray.cs</Link>
     </Compile>
-    <Compile Include="$(CompilerCommonPath)\Internal\Runtime\CanonTypeKind.cs">
-      <Link>Internal\Runtime\CanonTypeKind.cs</Link>
-    </Compile>
     <Compile Include="$(AotCommonPath)\System\Runtime\RhFailFastReason.cs">
       <Link>System\Runtime\RhFailFastReason.cs</Link>
     </Compile>

src/coreclr/nativeaot/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/ExecutionEnvironmentImplementation.MappingTables.cs

@@ -227,28 +227,8 @@ public sealed override MethodBaseInvoker TryGetMethodInvokerNoConstraintCheck(Ru
         {
             MethodBase methodInfo = ExecutionDomain.GetMethod(declaringTypeHandle, methodHandle, genericMethodTypeArgumentHandles);
 
-            MethodInvokeInfo methodInvokeInfo;
-#if GENERICS_FORCE_USG
-            // Stress mode to force the usage of universal canonical method targets for reflection invokes.
-            // It is recommended to use "/SharedGenericsMode GenerateAllUniversalGenerics" NUTC command line argument when
-            // compiling the application in order to effectively use the GENERICS_FORCE_USG mode.
-
-            // If we are just trying to invoke a non-generic method on a non-generic type, we won't force the universal lookup
-            if (!RuntimeAugments.IsGenericType(declaringTypeHandle) && (genericMethodTypeArgumentHandles == null || genericMethodTypeArgumentHandles.Length == 0))
-                methodInvokeInfo = TryGetMethodInvokeInfo(declaringTypeHandle, methodHandle, genericMethodTypeArgumentHandles,
-                    methodInfo, ref methodSignatureComparer, CanonicalFormKind.Specific);
-            else
-                methodInvokeInfo = TryGetMethodInvokeInfo(declaringTypeHandle, methodHandle, genericMethodTypeArgumentHandles,
-                    methodInfo, ref methodSignatureComparer, CanonicalFormKind.Universal);
-#else
-            methodInvokeInfo = TryGetMethodInvokeInfo(declaringTypeHandle, methodHandle, genericMethodTypeArgumentHandles,
-                methodInfo, CanonicalFormKind.Specific);
-
-            // If we failed to get a MethodInvokeInfo for an exact method, or a canonically equivalent method, check if there is a universal canonically
-            // equivalent entry that could be used (it will be much slower, and require a calling convention converter)
-            methodInvokeInfo ??= TryGetMethodInvokeInfo(declaringTypeHandle, methodHandle, genericMethodTypeArgumentHandles,
-                    methodInfo, CanonicalFormKind.Universal);
-#endif
+            MethodInvokeInfo methodInvokeInfo = TryGetMethodInvokeInfo(declaringTypeHandle, methodHandle, genericMethodTypeArgumentHandles,
+                methodInfo);
 
             if (methodInvokeInfo == null)
                 return null;
@@ -307,22 +287,19 @@ private static IntPtr TryGetVirtualResolveData(RuntimeTypeHandle methodHandleDec
         /// <param name="methodHandle">Handle of method to look up</param>
         /// <param name="genericMethodTypeArgumentHandles">Runtime handles of generic method arguments</param>
         /// <param name="methodInfo">MethodInfo of method to look up</param>
-        /// <param name="canonFormKind">Requested canon form</param>
         /// <returns>Constructed method invoke info, null on failure</returns>
         private static unsafe MethodInvokeInfo TryGetMethodInvokeInfo(
             RuntimeTypeHandle declaringTypeHandle,
             QMethodDefinition methodHandle,
             RuntimeTypeHandle[] genericMethodTypeArgumentHandles,
-            MethodBase methodInfo,
-            CanonicalFormKind canonFormKind)
+            MethodBase methodInfo)
         {
             MethodInvokeMetadata methodInvokeMetadata;
 
             if (!TypeLoaderEnvironment.TryGetMethodInvokeMetadata(
                 declaringTypeHandle,
                 methodHandle,
                 genericMethodTypeArgumentHandles,
-                canonFormKind,
                 out methodInvokeMetadata))
             {
                 // Method invoke info not found
@@ -740,8 +717,7 @@ public sealed override FieldAccessor TryGetFieldAccessor(
         {
             FieldAccessMetadata fieldAccessMetadata;
 
-            if (!TypeLoaderEnvironment.TryGetFieldAccessMetadata(
-                metadataReader,
+            if (!TypeLoaderEnvironment.TryGetFieldAccessMetadataFromFieldAccessMap(
                 declaringTypeHandle,
                 fieldHandle,
                 out fieldAccessMetadata))
@@ -788,8 +764,6 @@ public sealed override FieldAccessor TryGetFieldAccessor(
                         }
                         else
                         {
-                            Debug.Assert((fieldAccessMetadata.Flags & FieldTableFlags.IsUniversalCanonicalEntry) == 0);
-
                             if (fieldBase != FieldTableFlags.NonGCStatic)
                             {
                                 fieldOffset = fieldAccessMetadata.Offset;

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/CanonicallyEquivalentEntryLocator.cs

@@ -17,9 +17,8 @@ public struct CanonicallyEquivalentEntryLocator
         private RuntimeTypeHandle _genericDefinition;
         private RuntimeTypeHandle[] _genericArgs;
         private DefType _defType;
-        private CanonicalFormKind _canonKind;
 
-        public CanonicallyEquivalentEntryLocator(RuntimeTypeHandle typeToFind, CanonicalFormKind kind)
+        public CanonicallyEquivalentEntryLocator(RuntimeTypeHandle typeToFind)
         {
             if (RuntimeAugments.IsGenericType(typeToFind))
             {
@@ -32,16 +31,14 @@ public CanonicallyEquivalentEntryLocator(RuntimeTypeHandle typeToFind, Canonical
             }
 
             _typeToFind = typeToFind;
-            _canonKind = kind;
             _defType = null;
         }
 
-        internal CanonicallyEquivalentEntryLocator(DefType typeToFind, CanonicalFormKind kind)
+        internal CanonicallyEquivalentEntryLocator(DefType typeToFind)
         {
             _genericArgs = null;
             _genericDefinition = default(RuntimeTypeHandle);
             _typeToFind = default(RuntimeTypeHandle);
-            _canonKind = kind;
             _defType = typeToFind;
         }
 
@@ -50,10 +47,10 @@ public int LookupHashCode
             get
             {
                 if (_defType != null)
-                    return _defType.ConvertToCanonForm(_canonKind).GetHashCode();
+                    return _defType.ConvertToCanonForm(CanonicalFormKind.Specific).GetHashCode();
 
                 if (!_genericDefinition.IsNull())
-                    return TypeLoaderEnvironment.Instance.GetCanonicalHashCode(_typeToFind, _canonKind);
+                    return TypeLoaderEnvironment.Instance.GetCanonicalHashCode(_typeToFind, CanonicalFormKind.Specific);
                 else
                     return _typeToFind.GetHashCode();
             }
@@ -63,9 +60,9 @@ public bool IsCanonicallyEquivalent(RuntimeTypeHandle other)
         {
             if (_defType != null)
             {
-                TypeDesc typeToFindAsCanon = _defType.ConvertToCanonForm(_canonKind);
+                TypeDesc typeToFindAsCanon = _defType.ConvertToCanonForm(CanonicalFormKind.Specific);
                 TypeDesc otherTypeAsTypeDesc = _defType.Context.ResolveRuntimeTypeHandle(other);
-                TypeDesc otherTypeAsCanon = otherTypeAsTypeDesc.ConvertToCanonForm(_canonKind);
+                TypeDesc otherTypeAsCanon = otherTypeAsTypeDesc.ConvertToCanonForm(CanonicalFormKind.Specific);
                 return typeToFindAsCanon == otherTypeAsCanon;
             }
 
@@ -77,7 +74,7 @@ public bool IsCanonicallyEquivalent(RuntimeTypeHandle other)
                     RuntimeTypeHandle[] otherGenericArgs;
                     otherGenericDefinition = RuntimeAugments.GetGenericInstantiation(other, out otherGenericArgs);
 
-                    return _genericDefinition.Equals(otherGenericDefinition) && TypeLoaderEnvironment.Instance.CanInstantiationsShareCode(_genericArgs, otherGenericArgs, _canonKind);
+                    return _genericDefinition.Equals(otherGenericDefinition) && TypeLoaderEnvironment.Instance.CanInstantiationsShareCode(_genericArgs, otherGenericArgs, CanonicalFormKind.Specific);
                 }
                 else
                     return false;

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/EETypeCreator.cs

@@ -216,8 +216,6 @@ private static void CreateEETypeWorker(MethodTable* pTemplateEEType, uint hashCo
                 if (state.ThreadDataSize != 0)
                     dynamicTypeFlags |= DynamicTypeFlags.HasThreadStatics;
 
-                // Note: The number of vtable slots on the MethodTable to create is not necessary equal to the number of
-                // vtable slots on the template type for universal generics (see ComputeVTableLayout)
                 ushort numVtableSlots = state.NumVTableSlots;
 
                 // Compute the MethodTable size and allocate it

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/GenericDictionaryCell.cs

@@ -242,9 +242,6 @@ internal override unsafe void Prepare(TypeBuilder builder)
 
             internal override IntPtr Create(TypeBuilder builder)
             {
-                // TODO (USG): What if this method's instantiation is a non-shareable one (from a normal canonical
-                // perspective) and there's an exact method pointer for the method in question, do we still
-                // construct a method dictionary to be used with the universal canonical method implementation?
                 Debug.Assert(GenericMethod.RuntimeMethodDictionary != IntPtr.Zero);
                 return GenericMethod.RuntimeMethodDictionary;
             }

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TemplateLocator.cs

@@ -56,10 +56,6 @@ private static TypeDesc TryGetTypeTemplate_Internal(TypeDesc concreteType, Canon
                             continue;
                         }
 
-                        Debug.Assert(
-                            (kind != CanonicalFormKind.Universal) ||
-                            (kind == CanonicalFormKind.Universal && candidateTemplate == candidateTemplate.ConvertToCanonForm(kind)));
-
                         nativeLayoutInfoModule = moduleInfo;
                         return candidateTemplate;
                     }
@@ -126,10 +122,6 @@ private static InstantiatedMethod TryGetGenericMethodTemplate_Internal(Instantia
                             continue;
                         }
 
-                        Debug.Assert(
-                            (kind != CanonicalFormKind.Universal) ||
-                            (kind == CanonicalFormKind.Universal && candidateTemplate == candidateTemplate.GetCanonMethodTarget(kind)));
-
                         return candidateTemplate;
                     }
                 }

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeBuilder.cs

@@ -322,10 +322,6 @@ internal void ParseNativeLayoutInfo(InstantiatedMethod method)
                 }
             }
 
-            // Ensure that if this method is non-shareable from a normal canonical perspective, then
-            // its template MUST be a universal canonical template method
-            Debug.Assert(!method.IsNonSharableMethod || (method.IsNonSharableMethod && templateMethod.IsCanonicalMethod(CanonicalFormKind.Universal)));
-
             NativeReader nativeLayoutInfoReader = TypeLoaderEnvironment.GetNativeLayoutInfoReader(nativeLayoutModule.Handle);
 
             var methodInfoParser = new NativeParser(nativeLayoutInfoReader, nativeLayoutInfoToken);
@@ -361,12 +357,6 @@ internal void ParseNativeLayoutInfo(TypeBuilderState state, TypeDesc type)
         {
             TypeLoaderLogger.WriteLine("Parsing NativeLayoutInfo for type " + type.ToString() + " ...");
 
-            bool isTemplateUniversalCanon = false;
-            if (state.TemplateType != null)
-            {
-                isTemplateUniversalCanon = state.TemplateType.IsCanonicalSubtype(CanonicalFormKind.Universal);
-            }
-
             if (state.TemplateType == null)
             {
                 throw new MissingTemplateException();
@@ -427,15 +417,8 @@ internal void ParseNativeLayoutInfo(TypeBuilderState state, TypeDesc type)
                         state.ThreadStaticDesc = context.GetGCStaticInfo(typeInfoParser.GetUnsigned());
                         break;
 
-                    case BagElementKind.FieldLayout:
-                        TypeLoaderLogger.WriteLine("Found BagElementKind.FieldLayout");
-                        typeInfoParser.SkipInteger(); // Handled in type layout algorithm
-                        break;
-
                     case BagElementKind.DictionaryLayout:
                         TypeLoaderLogger.WriteLine("Found BagElementKind.DictionaryLayout");
-                        Debug.Assert(!isTemplateUniversalCanon, "Universal template nativelayout do not have DictionaryLayout");
-
                         Debug.Assert(state.Dictionary == null);
                         if (!state.TemplateType.RetrieveRuntimeTypeHandleIfPossible())
                         {

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeBuilderState.cs

@@ -85,7 +85,7 @@ public TypeDesc TemplateType
 
                     _templateTypeLoaderNativeLayout = true;
                     _templateComputed = true;
-                    if ((_templateType != null) && !_templateType.IsCanonicalSubtype(CanonicalFormKind.Universal))
+                    if (_templateType != null)
                         _nativeLayoutTokenComputed = true;
                 }
 
@@ -267,7 +267,6 @@ private ushort ComputeNumVTableSlots()
                     }
                     else
                     {
-                        // This should only happen for non-universal templates
                         Debug.Assert(TypeBeingBuilt.IsTemplateCanonical());
 
                         TypeDesc templateType = TypeBeingBuilt.ComputeTemplate(false);

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.ConstructedGenericMethodsLookup.cs

@@ -247,8 +247,6 @@ public bool TryGetGenericVirtualMethodPointer(InstantiatedMethod method, out Int
         {
             if (!method.CanShareNormalGenericCode())
             {
-                // First see if we can find an exact method implementation for the GVM (avoid using USG implementations if we can,
-                // because USG code is much slower).
                 if (TryLookupExactMethodPointer(method, out methodPointer))
                 {
                     Debug.Assert(methodPointer != IntPtr.Zero);

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.FieldAccess.cs

@@ -41,58 +41,21 @@ public struct FieldAccessMetadata
 
     public sealed partial class TypeLoaderEnvironment
     {
-        /// <summary>
-        /// Try to look up field access info for given canon in metadata blobs for all available modules.
-        /// </summary>
-        /// <param name="metadataReader">Metadata reader for the declaring type</param>
-        /// <param name="runtimeTypeHandle">Declaring type for the method</param>
-        /// <param name="fieldHandle">Field handle</param>
-        /// <param name="fieldAccessMetadata">Output - metadata information for field accessor construction</param>
-        /// <returns>true when found, false otherwise</returns>
-        public static bool TryGetFieldAccessMetadata(
-            MetadataReader metadataReader,
-            RuntimeTypeHandle runtimeTypeHandle,
-            FieldHandle fieldHandle,
-            out FieldAccessMetadata fieldAccessMetadata)
-        {
-            fieldAccessMetadata = default(FieldAccessMetadata);
-
-            if (TryGetFieldAccessMetadataFromFieldAccessMap(
-                runtimeTypeHandle,
-                fieldHandle,
-                CanonicalFormKind.Specific,
-                ref fieldAccessMetadata))
-            {
-                return true;
-            }
-
-            if (TryGetFieldAccessMetadataFromFieldAccessMap(
-                runtimeTypeHandle,
-                fieldHandle,
-                CanonicalFormKind.Universal,
-                ref fieldAccessMetadata))
-            {
-                return true;
-            }
-
-            return false;
-        }
-
         /// <summary>
         /// Try to look up field access info for given canon in metadata blobs for all available modules.
         /// </summary>
         /// <param name="declaringTypeHandle">Declaring type for the method</param>
         /// <param name="fieldHandle">Field handle</param>
-        /// <param name="canonFormKind">Canonical form to use</param>
         /// <param name="fieldAccessMetadata">Output - metadata information for field accessor construction</param>
         /// <returns>true when found, false otherwise</returns>
-        private static unsafe bool TryGetFieldAccessMetadataFromFieldAccessMap(
+        public static unsafe bool TryGetFieldAccessMetadataFromFieldAccessMap(
             RuntimeTypeHandle declaringTypeHandle,
             FieldHandle fieldHandle,
-            CanonicalFormKind canonFormKind,
-            ref FieldAccessMetadata fieldAccessMetadata)
+            out FieldAccessMetadata fieldAccessMetadata)
         {
-            CanonicallyEquivalentEntryLocator canonWrapper = new CanonicallyEquivalentEntryLocator(declaringTypeHandle, canonFormKind);
+            fieldAccessMetadata = default;
+
+            CanonicallyEquivalentEntryLocator canonWrapper = new CanonicallyEquivalentEntryLocator(declaringTypeHandle);
 
             foreach (NativeFormatModuleInfo mappingTableModule in ModuleList.EnumerateModules(RuntimeAugments.GetModuleFromTypeHandle(declaringTypeHandle)))
             {
@@ -119,9 +82,6 @@ private static unsafe bool TryGetFieldAccessMetadataFromFieldAccessMap(
 
                     FieldTableFlags entryFlags = (FieldTableFlags)entryParser.GetUnsigned();
 
-                    if ((canonFormKind == CanonicalFormKind.Universal) != ((entryFlags & FieldTableFlags.IsUniversalCanonicalEntry) != 0))
-                        continue;
-
                     RuntimeTypeHandle entryDeclaringTypeHandle = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
                     if (!entryDeclaringTypeHandle.Equals(declaringTypeHandle)
                         && !canonWrapper.IsCanonicallyEquivalent(entryDeclaringTypeHandle))
@@ -134,7 +94,6 @@ private static unsafe bool TryGetFieldAccessMetadataFromFieldAccessMap(
                     int fieldOffset;
                     IntPtr fieldAddressCookie = IntPtr.Zero;
 
-                    Debug.Assert(canonFormKind != CanonicalFormKind.Universal);
                     if ((entryFlags & FieldTableFlags.FieldOffsetEncodedDirectly) != 0)
                     {
                         fieldOffset = (int)entryParser.GetUnsigned();