Add dependency analysis that better ensures that templates are useable

- In PrecomputedMetadataManager
  - root Canonical Method instantiation in addition to UniversalCanon instantiation of all specified inputs
  - For virtual template virtual methods, root the method itself if it isn't abstract in addition to rooting the virtual method use
- ArrayMapNode
  - There must be no entries in the ArrayMap which are merely Necessary. This will cause the runtime to possibly use those directly if there is an attempt to create an array dynamically. (This results in NecessaryEETypeNodes allocated on the GC heap, which leads to crashes in the GC heap)
- EETypeNode
  - Previous change to this file attempted to avoid having a check on EmitVirtualSlotsAndInterfaces... turns out its still necessary or the compiler crashes in some cases.
- GVMDependenciesNode
  - Enable GVM analysis on ProjectN in EnableFullAnalysis mode
- NativeLayoutVertexNode.cs
  - Add dependencies to each NativeLayoutGenericDictionarySlotNode to require that all types referred to directly from slots are sufficiently loaded as to ensure that the template type loader can process those types.
  - Add dependencies to the TypeTemplate and MethodTemplate node to ensure that the template itself is safely describable
  - Add dependencies to the TypeTemplate to ensure that the base type and interfaces of a type are properly describable
  - Add dependencies to NativeLayoutTemplateMethodSignatureVertexNode so that the various uses of that node will work correctly
- NodeFactory.NativeLayout
  - Add helpers used to identify the nodes needed to ensure that a given type are template loadable.
- DefaultConstructorMapNode
  - Add handling for ensuring that not just the constructor method, but also it's type is constructed

[tfs-changeset: 1679633]

Author: davidwrighton

src/ILCompiler.Compiler/src/Compiler/DependencyAnalysis/ArrayMapNode.cs

@@ -52,7 +52,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
             Section hashTableSection = writer.NewSection();
             hashTableSection.Place(typeMapHashTable);
 
-            foreach (var type in factory.MetadataManager.GetTypesWithEETypes())
+            foreach (var type in factory.MetadataManager.GetTypesWithConstructedEETypes())
             {
                 if (!type.IsSzArray)
                     continue;
@@ -62,8 +62,8 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
                 if (!arrayType.ElementType.IsValueType)
                     continue;
 
-                // Go with a necessary type symbol. It will be upgraded to a constructed one if a constructed was emitted.
-                IEETypeNode arrayTypeSymbol = factory.NecessaryTypeSymbol(arrayType);
+                // Look at the constructed type symbol. If a constructed type wasn't emitted, then the array map entry isn't valid for use
+                IEETypeNode arrayTypeSymbol = factory.ConstructedTypeSymbol(arrayType);
 
                 Vertex vertex = writer.GetUnsignedConstant(_externalReferences.GetIndex(arrayTypeSymbol));
 

src/ILCompiler.Compiler/src/Compiler/DependencyAnalysis/DefaultConstructorMapNode.cs

@@ -41,6 +41,10 @@ public DefaultConstructorFromLazyNode(TypeDesc type)
 
         public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context)
         {
+            yield return new DependencyListEntry(
+                context.MaximallyConstructableType(TypeNeedingDefaultCtor),
+                "DefaultConstructorNode type");
+
             yield return new DependencyListEntry(
                 context.MethodEntrypoint(TypeNeedingDefaultCtor.GetDefaultConstructor(), TypeNeedingDefaultCtor.IsValueType), 
                 "DefaultConstructorNode");

src/ILCompiler.Compiler/src/Compiler/DependencyAnalysis/EETypeNode.cs

@@ -218,6 +218,9 @@ public sealed override IEnumerable<CombinedDependencyListEntry> GetConditionalSt
                 yield break;
             }
 
+            if (!EmitVirtualSlotsAndInterfaces)
+                yield break;
+
             DefType defType = _type.GetClosestDefType();
 
             // If we're producing a full vtable, none of the dependencies are conditional.

src/ILCompiler.Compiler/src/Compiler/DependencyAnalysis/GVMDependenciesNode.cs

@@ -107,7 +107,7 @@ public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependenci
             List<CombinedDependencyListEntry> dynamicDependencies = new List<CombinedDependencyListEntry>();
 
             // Disable dependence tracking for ProjectN
-            if (factory.Target.Abi == TargetAbi.ProjectN)
+            if ((factory.Target.Abi == TargetAbi.ProjectN) && !ProjectNDependencyBehavior.EnableFullAnalysis)
             {
                 return dynamicDependencies;
             }

src/ILCompiler.Compiler/src/Compiler/DependencyAnalysis/NativeLayoutVertexNode.cs

@@ -689,6 +689,27 @@ protected override IMethodNode GetMethodEntrypointNode(NodeFactory factory, out
             unboxingStub = false;
             return methodEntryPointNode;
         }
+
+        public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context)
+        {
+            DependencyList dependencies = (DependencyList)base.GetStaticDependencies(context);
+
+            foreach (var arg in _method.Instantiation)
+            {
+                foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(arg))
+                {
+                    dependencies.Add(new DependencyListEntry(dependency, "Dependencies to make a generic method template viable Method Instantiation"));
+                }
+            }
+
+
+            foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(_method.OwningType))
+            {
+                dependencies.Add(new DependencyListEntry(dependency, "Dependencies to make a generic method template viable OwningType"));
+            }
+
+            return dependencies;
+        }
     }
 
     public sealed class NativeLayoutDictionarySignatureNode : NativeLayoutSavedVertexNode
@@ -810,10 +831,20 @@ public NativeLayoutTemplateMethodLayoutVertexNode(NodeFactory factory, MethodDes
 
         public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context)
         {
-            return new DependencyListEntry[]
+            foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(_method.OwningType))
             {
-                new DependencyListEntry(context.GenericDictionaryLayout(_method), "Dictionary layout"),
-            };
+                yield return new DependencyListEntry(dependency, "method OwningType itself must be template loadable");
+            }
+
+            foreach (var type in _method.Instantiation)
+            {
+                foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(type))
+                {
+                    yield return new DependencyListEntry(dependency, "method's instantiation arguments must be template loadable");
+                }
+            }
+
+            yield return new DependencyListEntry(context.GenericDictionaryLayout(_method), "Dictionary layout");
         }
 
         private int CompareDictionaryEntries(KeyValuePair<int, NativeLayoutVertexNode> left, KeyValuePair<int, NativeLayoutVertexNode> right)
@@ -924,11 +955,21 @@ public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFacto
 
             yield return new DependencyListEntry(typeNode, "Template EEType");
 
+            foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(_type))
+            {
+                yield return new DependencyListEntry(dependency, "type itslef must be template loadable");
+            }
+
             yield return new DependencyListEntry(context.GenericDictionaryLayout(_type.ConvertToCanonForm(CanonicalFormKind.Specific).GetClosestDefType()), "Dictionary layout");
 
             foreach (TypeDesc iface in _type.RuntimeInterfaces)
             {
                 yield return new DependencyListEntry(context.NativeLayout.TypeSignatureVertex(iface), "template interface list");
+
+                foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(iface))
+                {
+                    yield return new DependencyListEntry(dependency, "interface type dependency must be template loadable");
+                }
             }
 
             if (context.TypeSystemContext.HasLazyStaticConstructor(_type))
@@ -954,6 +995,11 @@ public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFacto
             if (_type.BaseType != null && _type.BaseType.IsRuntimeDeterminedSubtype)
             {
                 yield return new DependencyListEntry(context.NativeLayout.PlacedSignatureVertex(context.NativeLayout.TypeSignatureVertex(_type.BaseType)), "template base type");
+
+                foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(_type.BaseType))
+                {
+                    yield return new DependencyListEntry(dependency, "base type must be template loadable");
+                }
             }
             else if (_type.IsDelegate && _isUniversalCanon)
             {
@@ -1440,7 +1486,12 @@ public NativeLayoutTypeSignatureBasedGenericDictionarySlotNode(NodeFactory facto
 
         public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
-            return new DependencyListEntry[1] { new DependencyListEntry(_signature, "TypeSignature") };
+            yield return new DependencyListEntry(_signature, "TypeSignature");
+
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_type))
+            {
+                yield return new DependencyListEntry(dependency, "template construction dependency");
+            }
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)
@@ -1579,7 +1630,12 @@ public NativeLayoutStaticsGenericDictionarySlotNode(NodeFactory factory, TypeDes
         protected sealed override FixupSignatureKind SignatureKind => FixupSignatureKind.StaticData;
         public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
-            return new DependencyListEntry[1] { new DependencyListEntry(_signature, "TypeSignature") };
+            yield return new DependencyListEntry(_signature, "TypeSignature");
+
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_type))
+            {
+                yield return new DependencyListEntry(dependency, "template construction dependency");
+            }
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)
@@ -1632,6 +1688,11 @@ public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(No
             {
                 yield return new DependencyListEntry(factory.VirtualMethodUse(method), "Slot number");
             }
+
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(method.OwningType))
+            {
+                yield return new DependencyListEntry(dependency, "template construction dependency");
+            }
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)
@@ -1678,7 +1739,18 @@ public NativeLayoutMethodDictionaryGenericDictionarySlotNode(NodeFactory factory
         protected sealed override FixupSignatureKind SignatureKind => FixupSignatureKind.MethodDictionary;
         public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
-            return new DependencyListEntry[] { new DependencyListEntry(_wrappedNode, "wrappednode") };
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_method.OwningType))
+            {
+                yield return new DependencyListEntry(dependency, "template construction dependency for method OwningType");
+            }
+
+            foreach (var type in _method.Instantiation)
+            {
+                foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(type))
+                    yield return new DependencyListEntry(dependency, "template construction dependency for method Instantiation types");
+            }
+
+            yield return new DependencyListEntry(_wrappedNode, "wrappednode");
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)
@@ -1702,7 +1774,12 @@ public NativeLayoutFieldOffsetGenericDictionarySlotNode(FieldDesc field)
 
         public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
-            return new DependencyListEntry[1] { new DependencyListEntry(factory.NativeLayout.TypeSignatureVertex(_field.OwningType), "Field Containing Type Signature") };
+            yield return new DependencyListEntry(factory.NativeLayout.TypeSignatureVertex(_field.OwningType), "Field Containing Type Signature");
+
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_field.OwningType))
+            {
+                yield return new DependencyListEntry(dependency, "template construction dependency");
+            }
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)
@@ -1731,7 +1808,12 @@ public NativeLayoutFieldLdTokenGenericDictionarySlotNode(FieldDesc field)
 
         public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
-            return new DependencyListEntry[1] { new DependencyListEntry(factory.NativeLayout.FieldLdTokenVertex(_field), "Field Signature") };
+            yield return new DependencyListEntry(factory.NativeLayout.FieldLdTokenVertex(_field), "Field Signature");
+
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_field.OwningType))
+            {
+                yield return new DependencyListEntry(dependency, "template construction dependency");
+            }
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)
@@ -1764,7 +1846,12 @@ public NativeLayoutVTableOffsetGenericDictionarySlotNode(MethodDesc method)
 
         public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
-            return new DependencyListEntry[1] { new DependencyListEntry(factory.NativeLayout.TypeSignatureVertex(_slotDefiningMethod.OwningType), "Method VTableOffset Containing Type Signature") };
+            yield return new DependencyListEntry(factory.NativeLayout.TypeSignatureVertex(_slotDefiningMethod.OwningType), "Method VTableOffset Containing Type Signature");
+
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_slotDefiningMethod.OwningType))
+            {
+                yield return new DependencyListEntry(dependency, "template construction dependency");
+            }
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)
@@ -1792,7 +1879,18 @@ public NativeLayoutMethodLdTokenGenericDictionarySlotNode(MethodDesc method)
 
         public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
-            return new DependencyListEntry[1] { new DependencyListEntry(factory.NativeLayout.MethodLdTokenVertex(_method), "Method Signature") };
+            yield return new DependencyListEntry(factory.NativeLayout.MethodLdTokenVertex(_method), "Method Signature");
+
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_method.OwningType))
+            {
+                yield return new DependencyListEntry(dependency, "template construction dependency for method OwningType");
+            }
+
+            foreach (var type in _method.Instantiation)
+            {
+                foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(type))
+                    yield return new DependencyListEntry(dependency, "template construction dependency for method Instantiation types");
+            }
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)
@@ -1821,7 +1919,19 @@ protected sealed override string GetName(NodeFactory factory) =>
 
         public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
-            return new DependencyListEntry[1] { new DependencyListEntry(factory.NativeLayout.MethodSignatureVertex(_signature), "Method Signature") };
+            yield return new DependencyListEntry(factory.NativeLayout.MethodSignatureVertex(_signature), "Method Signature");
+
+            for (int i = 0; i < _signature.Length; i++)
+            {
+                foreach (var dep in factory.NativeLayout.UniversalTemplateConstructableTypes(_signature[i]))
+                {
+                    yield return new DependencyListEntry(dep, "template construction dependency");
+                }
+            }
+            foreach (var dep in factory.NativeLayout.UniversalTemplateConstructableTypes(_signature.ReturnType))
+            {
+                yield return new DependencyListEntry(dep, "template construction dependency");
+            }
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)
@@ -1868,10 +1978,23 @@ public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(No
                 constrainedMethodDescriptorNode = factory.NativeLayout.TypeSignatureVertex(_constrainedMethod.OwningType);
             }
 
-            return new DependencyListEntry[] {
-                new DependencyListEntry(factory.NativeLayout.TypeSignatureVertex(_constraintType), "ConstraintType"),
-                new DependencyListEntry(constrainedMethodDescriptorNode, "ConstrainedMethodType"),
-            };
+            yield return new DependencyListEntry(factory.NativeLayout.TypeSignatureVertex(_constraintType), "ConstraintType");
+
+            yield return new DependencyListEntry(constrainedMethodDescriptorNode, "ConstrainedMethodType");
+
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_constrainedMethod.OwningType))
+            {
+                yield return new DependencyListEntry(dependency, "template construction dependency constrainedMethod OwningType");
+            }
+
+            foreach (var type in _constrainedMethod.Instantiation)
+            {
+                foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(type))
+                    yield return new DependencyListEntry(dependency, "template construction dependency constrainedMethod Instantiation type");
+            }
+
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_constraintType))
+                yield return new DependencyListEntry(dependency, "template construction dependency constraintType");
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)
@@ -1932,7 +2055,18 @@ public NativeLayoutMethodEntrypointGenericDictionarySlotNode(NodeFactory factory
         protected sealed override FixupSignatureKind SignatureKind => FixupSignatureKind.Method;
         public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
-            return new DependencyListEntry[] { new DependencyListEntry(_wrappedNode, "wrappednode") };
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_method.OwningType))
+            {
+                yield return new DependencyListEntry(dependency, "template construction dependency for method OwningType");
+            }
+
+            foreach (var type in _method.Instantiation)
+            {
+                foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(type))
+                    yield return new DependencyListEntry(dependency, "template construction dependency for method Instantiation types");
+            }
+
+            yield return new DependencyListEntry(_wrappedNode, "wrappednode");
         }
 
         protected sealed override Vertex WriteSignatureVertex(NativeWriter writer, NodeFactory factory)