Only add GVMDependencies for types with used GVMs (#118704)

Ever since GVM support was added to native AOT, we were generating the GVM resolution metadata for every type considered allocated. This included GVMs that were never even called: see `TypeGVMEntriesNode` that simply goes over everything on the type - we were adding a `TypeGVMEntriesNode` for all allocated types that have something to do with GVMs.

This PR changes it so that we only generate `TypeGVMEntries` for types that have at least one used GVM. This is a scoped down version of #118632 (that tries to track things per-method) with a lot less risk.

Author: MichalStrehovsky

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ConstructedEETypeNode.cs

@@ -52,15 +52,7 @@ protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFact
 
             dependencyList.Add(factory.VTable(closestDefType), "VTable");
 
-            if (_type.IsCanonicalSubtype(CanonicalFormKind.Any))
-            {
-                // Track generic virtual methods that will get added to the GVM tables
-                if ((_virtualMethodAnalysisFlags & VirtualMethodAnalysisFlags.NeedsGvmEntries) != 0)
-                {
-                    dependencyList.Add(new DependencyListEntry(factory.TypeGVMEntries(_type.GetTypeDefinition()), "Type with generic virtual methods"));
-                }
-            }
-            else
+            if (!_type.IsCanonicalSubtype(CanonicalFormKind.Any))
             {
                 factory.InteropStubManager.AddInterestingInteropConstructedTypeDependencies(ref dependencyList, factory, _type);
             }

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/EETypeNode.cs

@@ -628,8 +628,6 @@ protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFact
                 // Generated type contains generic virtual methods that will get added to the GVM tables
                 if ((_virtualMethodAnalysisFlags & VirtualMethodAnalysisFlags.NeedsGvmEntries) != 0)
                 {
-                    dependencies.Add(new DependencyListEntry(factory.TypeGVMEntries(_type.GetTypeDefinition()), "Type with generic virtual methods"));
-
                     TypeDesc canonicalType = _type.ConvertToCanonForm(CanonicalFormKind.Specific);
                     if (canonicalType != _type)
                         dependencies.Add(factory.ConstructedTypeSymbol(canonicalType), "Type with generic virtual methods");

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/GVMDependenciesNode.cs

@@ -41,7 +41,14 @@ public GVMDependenciesNode(MethodDesc method)
         public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
             if (!_method.IsAbstract)
+            {
                 yield return new DependencyListEntry(factory.GenericVirtualMethodImpl(_method), "Implementation of the generic virtual method");
+            }
+
+            if (!_method.OwningType.IsInterface)
+            {
+                yield return new DependencyListEntry(factory.TypeGVMEntries(_method.OwningType.GetTypeDefinition()), "Resolution metadata");
+            }
         }
 
         public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory context) => null;
@@ -95,6 +102,8 @@ public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependenci
                     potentialOverrideType.ConvertToCanonForm(CanonicalFormKind.Specific) != potentialOverrideType)
                     continue;
 
+                bool foundImpl = false;
+
                 // If this is an interface gvm, look for types that implement the interface
                 // and other instantantiations that have the same canonical form.
                 // This ensure the various slot numbers remain equivalent across all types where there is an equivalence
@@ -150,6 +159,8 @@ public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependenci
                                 TypeSystemEntity origin = (implementingMethodInstantiation.OwningType != potentialOverrideType) ? potentialOverrideType : null;
                                 factory.MetadataManager.NoteOverridingMethod(_method, implementingMethodInstantiation, origin);
                             }
+
+                            foundImpl = true;
                         }
                     }
                 }
@@ -201,7 +212,20 @@ public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependenci
                             factory.GenericVirtualMethodImpl(instantiatedTargetMethod), null, "DerivedMethodInstantiation"));
 
                         factory.MetadataManager.NoteOverridingMethod(_method, instantiatedTargetMethod);
+
+                        foundImpl = true;
+                    }
+                }
+
+                if (foundImpl)
+                {
+                    TypeDesc currentType = potentialOverrideType;
+                    do
+                    {
+                        dynamicDependencies.Add(new CombinedDependencyListEntry(factory.TypeGVMEntries(currentType.GetTypeDefinition()), null, "Resolution metadata"));
+                        currentType = currentType.BaseType;
                     }
+                    while (currentType != null);
                 }
             }