Linker dependency framework

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/ILCompiler.DependencyAnalysisFramework.csproj

@@ -8,6 +8,10 @@
     <Platforms>x64;x86</Platforms>
     <PlatformTarget>AnyCPU</PlatformTarget>
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <!-- Workaround for circular dependency (this => trim analyzers in illink.Tasks => Mono.Linker => this)-->
+    <_RequiresLiveILLink>false</_RequiresLiveILLink>
+    <!-- Mono.Linker requires the assembly to be signed -->
+    <SignAssembly>true</SignAssembly>
 
     <!-- We're binplacing these into an existing publish layout so that F5 build in VS updates
          the same bits tests expect to see in artifacts/crossgen2. That way we never need to wonder which

src/tools/illink/src/linker/Linker.Steps/MarkStep.MarkStepNodeFactory.cs

@@ -0,0 +1,65 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using Mono.Cecil;
+
+namespace Mono.Linker.Steps
+{
+	public partial class MarkStep
+	{
+		internal sealed class MarkStepNodeFactory (MarkStep markStep)
+		{
+			public MarkStep MarkStep { get; } = markStep;
+			readonly NodeCache<TypeDefinition, TypeDefinitionDependencyNode> _typeNodes = new (static _ => throw new InvalidOperationException ("Creation of node requires more than the key."));
+			readonly NodeCache<MethodDefinition, MethodDefinitionDependencyNode> _methodNodes = new (static _ => throw new InvalidOperationException ("Creation of node requires more than the key."));
+			readonly NodeCache<TypeDefinition, TypeIsRelevantToVariantCastingNode> _typeIsRelevantToVariantCastingNodes = new (static (t) => new TypeIsRelevantToVariantCastingNode (t));
+
+			internal TypeDefinitionDependencyNode GetTypeNode (TypeDefinition reference, DependencyInfo reason, MessageOrigin? origin)
+			{
+				return _typeNodes.GetOrAdd (reference, (k) => new TypeDefinitionDependencyNode (k, reason, origin));
+			}
+
+			internal MethodDefinitionDependencyNode GetMethodDefinitionNode (MethodDefinition method, DependencyInfo reason, MessageOrigin origin)
+			{
+				return _methodNodes.GetOrAdd (method, (k) => new MethodDefinitionDependencyNode (k, reason, origin));
+			}
+
+			internal TypeIsRelevantToVariantCastingNode GetTypeIsRelevantToVariantCastingNode (TypeDefinition type)
+			{
+				return _typeIsRelevantToVariantCastingNodes.GetOrAdd (type);
+			}
+
+			struct NodeCache<TKey, TValue> where TKey : notnull
+			{
+				// Change to concurrent dictionary if/when multithreaded marking is enabled
+				readonly Dictionary<TKey, TValue> _cache;
+				readonly Func<TKey, TValue> _creator;
+
+				public NodeCache (Func<TKey, TValue> creator, IEqualityComparer<TKey> comparer)
+				{
+					_creator = creator;
+					_cache = new (comparer);
+				}
+
+				public NodeCache (Func<TKey, TValue> creator)
+				{
+					_creator = creator;
+					_cache = new ();
+				}
+
+				public TValue GetOrAdd (TKey key)
+				{
+					return _cache.GetOrAdd (key, _creator);
+				}
+
+				public TValue GetOrAdd (TKey key, Func<TKey, TValue> creator)
+				{
+					return _cache.GetOrAdd (key, creator);
+				}
+			}
+		}
+	}
+}

src/tools/illink/src/linker/Linker.Steps/MarkStep.MethodDefinitionDependencyNode.cs

@@ -0,0 +1,45 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using ILCompiler.DependencyAnalysisFramework;
+using Mono.Cecil;
+
+namespace Mono.Linker.Steps
+{
+	public partial class MarkStep
+	{
+		internal sealed class MethodDefinitionDependencyNode : DependencyNodeCore<MarkStepNodeFactory>
+		{
+			readonly MethodDefinition method;
+			readonly MessageOrigin origin;
+			readonly DependencyInfo reason;
+
+			public MethodDefinitionDependencyNode (MethodDefinition method, DependencyInfo reason, MessageOrigin origin)
+			{
+				this.method = method;
+				this.origin = origin;
+				this.reason = reason;
+			}
+
+			public override bool InterestingForDynamicDependencyAnalysis => false;
+
+			public override bool HasDynamicDependencies => false;
+
+			public override bool HasConditionalStaticDependencies => false;
+
+			public override bool StaticDependenciesAreComputed => true;
+
+			public override IEnumerable<DependencyListEntry>? GetStaticDependencies (MarkStepNodeFactory context)
+			{
+				context.MarkStep.ProcessMethod (method, reason, origin);
+				return null;
+			}
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (MarkStepNodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<MarkStepNodeFactory>> markedNodes, int firstNode, MarkStepNodeFactory context) => null;
+			protected override string GetName (MarkStepNodeFactory context) => "MethodDefinition";
+		}
+	}
+}

src/tools/illink/src/linker/Linker.Steps/MarkStep.ProcessCallbackDependencyNode.cs

@@ -0,0 +1,43 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using ILCompiler.DependencyAnalysisFramework;
+
+namespace Mono.Linker.Steps
+{
+
+	public partial class MarkStep
+	{
+		sealed class ProcessCallbackDependencyNode : DependencyNodeCore<MarkStepNodeFactory>
+		{
+			Func<bool> _processAction;
+			DependencyList? _dependencies;
+
+			public ProcessCallbackDependencyNode (Func<bool> action) => _processAction = action;
+
+			public void Process ()
+			{
+				_dependencies = new DependencyList ();
+				if (_processAction ()) {
+					_dependencies.Add (new ProcessCallbackDependencyNode (_processAction), "Some processing was done, continuation required");
+				}
+			}
+
+			public override bool InterestingForDynamicDependencyAnalysis => false;
+
+			public override bool HasDynamicDependencies => false;
+
+			public override bool HasConditionalStaticDependencies => false;
+
+			public override bool StaticDependenciesAreComputed => _dependencies != null;
+
+			public override IEnumerable<DependencyListEntry>? GetStaticDependencies (MarkStepNodeFactory context) => _dependencies;
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (MarkStepNodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<MarkStepNodeFactory>> markedNodes, int firstNode, MarkStepNodeFactory context) => null;
+			protected override string GetName (MarkStepNodeFactory context) => "Process";
+		}
+	}
+}

src/tools/illink/src/linker/Linker.Steps/MarkStep.TypeDefinitionDependencyNode.cs

@@ -0,0 +1,49 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using ILCompiler.DependencyAnalysisFramework;
+using Mono.Cecil;
+
+namespace Mono.Linker.Steps
+{
+
+	public partial class MarkStep
+	{
+		internal sealed class TypeDefinitionDependencyNode : DependencyNodeCore<MarkStepNodeFactory>
+		{
+			readonly TypeDefinition type;
+			readonly MessageOrigin? origin;
+			readonly DependencyInfo reason;
+
+			public TypeDefinitionDependencyNode (TypeDefinition type, DependencyInfo reason, MessageOrigin? origin)
+			{
+				this.type = type;
+				this.origin = origin;
+				this.reason = reason;
+			}
+
+			public override bool InterestingForDynamicDependencyAnalysis => false;
+
+			public override bool HasDynamicDependencies => false;
+
+			public override bool HasConditionalStaticDependencies => false;
+
+			public override bool StaticDependenciesAreComputed => true;
+
+			public override IEnumerable<DependencyListEntry>? GetStaticDependencies (MarkStepNodeFactory context)
+			{
+				yield break;
+			}
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (MarkStepNodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<MarkStepNodeFactory>> markedNodes, int firstNode, MarkStepNodeFactory context) => null;
+			protected override string GetName (MarkStepNodeFactory context) => "TypeNode";
+			protected override void OnMarked (MarkStepNodeFactory context)
+			{
+				using MarkScopeStack.LocalScope? localScope = origin.HasValue ? context.MarkStep.ScopeStack.PushLocalScope (origin.Value) : null;
+				context.MarkStep.ProcessType (type, reason, origin);
+			}
+		}
+	}
+}

src/tools/illink/src/linker/Linker.Steps/MarkStep.TypeIsRelevantToVariantCastingNode.cs

@@ -0,0 +1,40 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using ILCompiler.DependencyAnalysisFramework;
+using Mono.Cecil;
+
+namespace Mono.Linker.Steps
+{
+
+	public partial class MarkStep
+	{
+		internal sealed class TypeIsRelevantToVariantCastingNode : DependencyNodeCore<MarkStepNodeFactory>
+		{
+			TypeDefinition type;
+			public TypeIsRelevantToVariantCastingNode (TypeDefinition type) => this.type = type;
+
+			public override bool InterestingForDynamicDependencyAnalysis => false;
+
+			public override bool HasDynamicDependencies => false;
+
+			public override bool HasConditionalStaticDependencies => false;
+
+			public override bool StaticDependenciesAreComputed => true;
+
+			public override IEnumerable<DependencyListEntry>? GetStaticDependencies (MarkStepNodeFactory context)
+			{
+				yield break;
+			}
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (MarkStepNodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<MarkStepNodeFactory>> markedNodes, int firstNode, MarkStepNodeFactory context) => null;
+			protected override string GetName (MarkStepNodeFactory context) => "TypeIsRelevantToVariantCasting";
+			protected override void OnMarked (MarkStepNodeFactory context)
+			{
+				context.MarkStep.Annotations.MarkRelevantToVariantCasting (type);
+			}
+		}
+	}
+}