diff --git a/eng/liveILLink.targets b/eng/liveILLink.targets
index f18b89622982d..6b45e00a49d5e 100644
--- a/eng/liveILLink.targets
+++ b/eng/liveILLink.targets
@@ -30,11 +30,13 @@
 
   <ItemGroup Condition="'$(_RequiresLiveILLink)' == 'true'">
     <!-- The assembly shouldn't be referenced, nor promoted to a package dependency, nor copied to the output directory. -->
+    <!-- ILLink.Tasks is architecture independent, so TargetArch and TargetOS should not be specified -->
     <ProjectReference Include="$(_ILLinkTasksSourceDir)ILLink.Tasks.csproj"
                       ReferenceOutputAssembly="false"
                       PrivateAssets="all"
                       Private="false"
-                      SetConfiguration="Configuration=$(ToolsConfiguration)">
+                      SetConfiguration="Configuration=$(ToolsConfiguration)"
+                      GlobalPropertiesToRemove="TargetArchitecture;TargetOS" >
         <!-- Keep TFMs in sync with ILLink.Tasks.csproj -->
         <SetTargetFramework Condition="'$(MSBuildRuntimeType)' == 'Core'">TargetFramework=$(NetCoreAppToolCurrent)</SetTargetFramework>
         <SetTargetFramework Condition="'$(MSBuildRuntimeType)' != 'Core'">TargetFramework=$(NetFrameworkToolCurrent)</SetTargetFramework>
diff --git a/src/coreclr/Directory.Build.props b/src/coreclr/Directory.Build.props
index 233bfbeacebf0..2f86002cccf44 100644
--- a/src/coreclr/Directory.Build.props
+++ b/src/coreclr/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <InferPlatformFromTargetArchitecture>true</InferPlatformFromTargetArchitecture>
+    <InferPlatformFromTargetArchitecture Condition="'$(InferPlatformFromTargetArchitecture)' == ''">true</InferPlatformFromTargetArchitecture>
 
     <!-- TODO: Clean-up casing and remove __BuildType to remove this block. -->
     <Configuration Condition="'$(Configuration)' == ''">$(__BuildType)</Configuration>
diff --git a/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/ILCompiler.DependencyAnalysisFramework.csproj b/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/ILCompiler.DependencyAnalysisFramework.csproj
index 28aa33b5afe73..763d6bfbc27bf 100644
--- a/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/ILCompiler.DependencyAnalysisFramework.csproj
+++ b/src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/ILCompiler.DependencyAnalysisFramework.csproj
@@ -1,4 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project>
+  <PropertyGroup>
+    <PlatformName>AnyCPU</PlatformName>
+  </PropertyGroup>
+  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
   <PropertyGroup>
     <OutputType>Library</OutputType>
     <RootNamespace>ILCompiler.DependencyAnalysisFramework</RootNamespace>
@@ -8,6 +12,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
@@ -50,4 +58,5 @@
       <Link>Sorting\MergeSortCore.cs</Link>
     </Compile>
   </ItemGroup>
+  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
 </Project>
diff --git a/src/tools/illink/src/linker/Linker.Steps/MarkScopeStack.cs b/src/tools/illink/src/linker/Linker.Steps/MarkScopeStack.cs
index ab1ad448754fc..6b5add70314cd 100644
--- a/src/tools/illink/src/linker/Linker.Steps/MarkScopeStack.cs
+++ b/src/tools/illink/src/linker/Linker.Steps/MarkScopeStack.cs
@@ -88,11 +88,6 @@ internal LocalScope PushLocalScope (in Scope scope)
 			return new LocalScope (scope, this);
 		}
 
-		internal ParentScope PopToParentScope ()
-		{
-			return new ParentScope (this);
-		}
-
 		public IDisposable PushScope (in MessageOrigin origin)
 		{
 			return new LocalScope (origin, this);
diff --git a/src/tools/illink/src/linker/Linker.Steps/MarkStep.MethodDefinitionNode.cs b/src/tools/illink/src/linker/Linker.Steps/MarkStep.MethodDefinitionNode.cs
new file mode 100644
index 0000000000000..34dd6e8a8d03e
--- /dev/null
+++ b/src/tools/illink/src/linker/Linker.Steps/MarkStep.MethodDefinitionNode.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;
+using Mono.Cecil;
+
+namespace Mono.Linker.Steps
+{
+	public partial class MarkStep
+	{
+		internal sealed class MethodDefinitionNode : DependencyNodeCore<NodeFactory>
+		{
+			readonly MethodDefinition method;
+			readonly DependencyInfo reason;
+
+			public MethodDefinitionNode (MethodDefinition method, DependencyInfo reason)
+			{
+				this.method = method;
+				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 (NodeFactory context)
+			{
+				context.MarkStep.ProcessMethod (method, reason);
+				return null;
+			}
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (NodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null;
+			protected override string GetName (NodeFactory context) => method.GetDisplayName();
+		}
+	}
+}
diff --git a/src/tools/illink/src/linker/Linker.Steps/MarkStep.NodeFactory.cs b/src/tools/illink/src/linker/Linker.Steps/MarkStep.NodeFactory.cs
new file mode 100644
index 0000000000000..7e16f7ac25981
--- /dev/null
+++ b/src/tools/illink/src/linker/Linker.Steps/MarkStep.NodeFactory.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 NodeFactory (MarkStep markStep)
+		{
+			public MarkStep MarkStep { get; } = markStep;
+			readonly NodeCache<TypeDefinition, TypeDefinitionNode> _typeNodes = new (static t => new TypeDefinitionNode(t));
+			readonly NodeCache<MethodDefinition, MethodDefinitionNode> _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 TypeDefinitionNode GetTypeNode (TypeDefinition definition)
+			{
+				return _typeNodes.GetOrAdd (definition);
+			}
+
+			internal MethodDefinitionNode GetMethodDefinitionNode (MethodDefinition method, DependencyInfo reason)
+			{
+				return _methodNodes.GetOrAdd (method, (k) => new MethodDefinitionNode (k, reason));
+			}
+
+			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);
+				}
+			}
+		}
+	}
+}
diff --git a/src/tools/illink/src/linker/Linker.Steps/MarkStep.ProcessCallbackNode.cs b/src/tools/illink/src/linker/Linker.Steps/MarkStep.ProcessCallbackNode.cs
new file mode 100644
index 0000000000000..9fe4821f44381
--- /dev/null
+++ b/src/tools/illink/src/linker/Linker.Steps/MarkStep.ProcessCallbackNode.cs
@@ -0,0 +1,42 @@
+// 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 ProcessCallbackNode : DependencyNodeCore<NodeFactory>
+		{
+			Func<bool> _processAction;
+			DependencyList? _dependencies;
+
+			public ProcessCallbackNode (Func<bool> action) => _processAction = action;
+
+			public void Process ()
+			{
+				_dependencies = new DependencyList ();
+				if (_processAction ()) {
+					_dependencies.Add (new ProcessCallbackNode (_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 (NodeFactory context) => _dependencies;
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (NodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null;
+			protected override string GetName (NodeFactory context) => "Process";
+		}
+	}
+}
diff --git a/src/tools/illink/src/linker/Linker.Steps/MarkStep.TypeDefinitionNode.cs b/src/tools/illink/src/linker/Linker.Steps/MarkStep.TypeDefinitionNode.cs
new file mode 100644
index 0000000000000..d26467930afce
--- /dev/null
+++ b/src/tools/illink/src/linker/Linker.Steps/MarkStep.TypeDefinitionNode.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 TypeDefinitionNode : DependencyNodeCore<NodeFactory>
+		{
+			readonly TypeDefinition type;
+
+			public TypeDefinitionNode (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 (NodeFactory context)
+			{
+				context.MarkStep.ProcessType (type);
+				return null;
+			}
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (NodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null;
+			protected override string GetName (NodeFactory context) => type.GetDisplayName();
+		}
+	}
+}
diff --git a/src/tools/illink/src/linker/Linker.Steps/MarkStep.TypeIsRelevantToVariantCastingNode.cs b/src/tools/illink/src/linker/Linker.Steps/MarkStep.TypeIsRelevantToVariantCastingNode.cs
new file mode 100644
index 0000000000000..00f790b5d9d47
--- /dev/null
+++ b/src/tools/illink/src/linker/Linker.Steps/MarkStep.TypeIsRelevantToVariantCastingNode.cs
@@ -0,0 +1,39 @@
+// 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<NodeFactory>
+		{
+			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 (NodeFactory context)
+			{
+				yield break;
+			}
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (NodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null;
+			protected override string GetName (NodeFactory context) => $"{type.GetDisplayName()} is relevant to variant casting";
+			protected override void OnMarked (NodeFactory context)
+			{
+				context.MarkStep.Annotations.MarkRelevantToVariantCasting (type);
+			}
+		}
+	}
+}
diff --git a/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs b/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs
index f26a176c30412..1731eac41d288 100644
--- a/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs
+++ b/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs
@@ -37,7 +37,9 @@
 using System.Linq;
 using System.Reflection.Metadata.Ecma335;
 using System.Reflection.Runtime.TypeParsing;
+using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
+using ILCompiler.DependencyAnalysisFramework;
 using ILLink.Shared;
 using ILLink.Shared.TrimAnalysis;
 using ILLink.Shared.TypeSystemProxy;
@@ -59,7 +61,7 @@ protected LinkContext Context {
 			}
 		}
 
-		protected Queue<(MethodDefinition, DependencyInfo, MessageOrigin)> _methods;
+		private bool _completed;
 		protected Dictionary<MethodDefinition, MarkScopeStack.Scope> _interface_methods;
 		protected Queue<AttributeProviderPair> _assemblyLevelAttributes;
 		protected Queue<(AttributeProviderPair, DependencyInfo, MarkScopeStack.Scope)> _lateMarkedAttributes;
@@ -73,6 +75,8 @@ protected LinkContext Context {
 		// Stores, for compiler-generated methods only, whether they require the reflection
 		// method body scanner.
 		readonly Dictionary<MethodBody, bool> _compilerGeneratedMethodRequiresScanner;
+		private readonly NodeFactory _nodeFactory;
+		private readonly DependencyAnalyzer<NoLogStrategy<NodeFactory>, NodeFactory> _dependencyGraph;
 
 		MarkStepContext? _markContext;
 		MarkStepContext MarkContext {
@@ -218,7 +222,7 @@ internal DynamicallyAccessedMembersTypeHierarchy DynamicallyAccessedMembersTypeH
 
 		public MarkStep ()
 		{
-			_methods = new Queue<(MethodDefinition, DependencyInfo, MessageOrigin)> ();
+			_completed = false;
 			_interface_methods = new Dictionary<MethodDefinition, MarkScopeStack.Scope> ();
 			_assemblyLevelAttributes = new Queue<AttributeProviderPair> ();
 			_lateMarkedAttributes = new Queue<(AttributeProviderPair, DependencyInfo, MarkScopeStack.Scope)> ();
@@ -229,6 +233,8 @@ public MarkStep ()
 			_pending_isinst_instr = new List<(TypeDefinition, MethodBody, Instruction)> ();
 			_entireTypesMarked = new HashSet<TypeDefinition> ();
 			_compilerGeneratedMethodRequiresScanner = new Dictionary<MethodBody, bool> ();
+			_nodeFactory = new NodeFactory (this);
+			_dependencyGraph = new DependencyAnalyzer<NoLogStrategy<NodeFactory>, NodeFactory> (_nodeFactory, null);
 		}
 
 		public AnnotationStore Annotations => Context.Annotations;
@@ -374,13 +380,23 @@ internal void MarkEntireType (TypeDefinition type, in DependencyInfo reason)
 
 		void Process ()
 		{
-			while (ProcessPrimaryQueue () ||
+			_dependencyGraph.ComputeDependencyRoutine += (List<DependencyNodeCore<NodeFactory>> nodes) => {
+				foreach (DependencyNodeCore<NodeFactory> node in nodes) {
+					if (node is ProcessCallbackNode processNode)
+						processNode.Process ();
+				}
+			};
+			_dependencyGraph.AddRoot (new ProcessCallbackNode (ProcessAllPendingItems), "start");
+			_dependencyGraph.ComputeMarkedNodes ();
+
+			ProcessPendingTypeChecks ();
+
+			bool ProcessAllPendingItems ()
+				=> ProcessPrimaryQueue () ||
 				ProcessMarkedPending () ||
 				ProcessLazyAttributes () ||
 				ProcessLateMarkedAttributes () ||
-				MarkFullyPreservedAssemblies ()) ;
-
-			ProcessPendingTypeChecks ();
+				MarkFullyPreservedAssemblies ();
 		}
 
 		static bool IsFullyPreservedAction (AssemblyAction action) => action == AssemblyAction.Copy || action == AssemblyAction.Save;
@@ -432,11 +448,11 @@ bool MarkFullyPreservedAssemblies ()
 
 		bool ProcessPrimaryQueue ()
 		{
-			if (QueueIsEmpty ())
+			if (_completed)
 				return false;
 
-			while (!QueueIsEmpty ()) {
-				ProcessQueue ();
+			while (!_completed) {
+				_completed = true;
 				ProcessInterfaceMethods ();
 				ProcessMarkedTypesWithInterfaces ();
 				ProcessDynamicCastableImplementationInterfaces ();
@@ -512,24 +528,6 @@ void ProcessPendingTypeChecks ()
 			}
 		}
 
-		void ProcessQueue ()
-		{
-			while (!QueueIsEmpty ()) {
-				(MethodDefinition method, DependencyInfo reason, MessageOrigin origin) = _methods.Dequeue ();
-				ProcessMethod (method, reason, origin);
-			}
-		}
-
-		bool QueueIsEmpty ()
-		{
-			return _methods.Count == 0;
-		}
-
-		protected virtual void EnqueueMethod (MethodDefinition method, in DependencyInfo reason, in MessageOrigin origin)
-		{
-			_methods.Enqueue ((method, reason, origin));
-		}
-
 		void ProcessInterfaceMethods ()
 		{
 			foreach ((var method, var scope) in _interface_methods) {
@@ -1900,7 +1898,7 @@ protected virtual void MarkSerializable (TypeDefinition type)
 			MarkMethodsIf (type.Methods, HasOnSerializeOrDeserializeAttribute, new DependencyInfo (DependencyKind.SerializationMethodForType, type), ScopeStack.CurrentScope.Origin);
 		}
 
-		protected internal virtual TypeDefinition? MarkTypeVisibleToReflection (TypeReference type, TypeDefinition definition, in DependencyInfo reason, in MessageOrigin origin)
+		protected internal virtual void MarkTypeVisibleToReflection (TypeReference type, TypeDefinition definition, in DependencyInfo reason, in MessageOrigin origin)
 		{
 			// If a type is visible to reflection, we need to stop doing optimization that could cause observable difference
 			// in reflection APIs. This includes APIs like MakeGenericType (where variant castability of the produced type
@@ -1911,7 +1909,7 @@ protected virtual void MarkSerializable (TypeDefinition type)
 
 			MarkImplicitlyUsedFields (definition);
 
-			return MarkType (type, reason, origin);
+			MarkType (type, reason, origin);
 		}
 
 		internal void MarkMethodVisibleToReflection (MethodReference method, in DependencyInfo reason, in MessageOrigin origin)
@@ -1956,6 +1954,7 @@ internal void MarkStaticConstructorVisibleToReflection (TypeDefinition type, in
 			MarkStaticConstructor (type, reason, origin);
 		}
 
+
 		/// <summary>
 		/// Marks the specified <paramref name="reference"/> as referenced.
 		/// </summary>
@@ -2017,6 +2016,12 @@ internal void MarkStaticConstructorVisibleToReflection (TypeDefinition type, in
 			if (type.Scope is ModuleDefinition module)
 				MarkModule (module, new DependencyInfo (DependencyKind.ScopeOfType, type));
 
+			_dependencyGraph.AddRoot (_nodeFactory.GetTypeNode (type), Enum.GetName (reason.Kind));
+			return type;
+		}
+
+		protected internal virtual void ProcessType (TypeDefinition type)
+		{
 			using var typeScope = ScopeStack.PushLocalScope (new MessageOrigin (type));
 
 			foreach (Action<TypeDefinition> handleMarkType in MarkContext.MarkTypeActions)
@@ -2051,7 +2056,7 @@ internal void MarkStaticConstructorVisibleToReflection (TypeDefinition type, in
 			}
 
 			if (type.IsClass && type.BaseType == null && type.Name == "Object" && ShouldMarkSystemObjectFinalize)
-				MarkMethodIf (type.Methods, m => m.Name == "Finalize", new DependencyInfo (DependencyKind.MethodForSpecialType, type), ScopeStack.CurrentScope.Origin);
+				MarkMethodIf (type.Methods, static m => m.Name == "Finalize", new DependencyInfo (DependencyKind.MethodForSpecialType, type), ScopeStack.CurrentScope.Origin);
 
 			MarkSerializable (type);
 
@@ -2104,9 +2109,8 @@ internal void MarkStaticConstructorVisibleToReflection (TypeDefinition type, in
 						MarkMethod (method, new DependencyInfo (DependencyKind.VirtualNeededDueToPreservedScope, type), ScopeStack.CurrentScope.Origin);
 					}
 				}
-				if (ShouldMarkTypeStaticConstructor (type) && reason.Kind != DependencyKind.TriggersCctorForCalledMethod) {
-					using (ScopeStack.PopToParentScope ())
-						MarkStaticConstructor (type, new DependencyInfo (DependencyKind.CctorForType, type), ScopeStack.CurrentScope.Origin);
+				if (ShouldMarkTypeStaticConstructor (type)) {
+					MarkStaticConstructor (type, new DependencyInfo (DependencyKind.CctorForType, type), ScopeStack.CurrentScope.Origin);
 				}
 			}
 
@@ -2115,7 +2119,7 @@ internal void MarkStaticConstructorVisibleToReflection (TypeDefinition type, in
 			ApplyPreserveInfo (type);
 			ApplyPreserveMethods (type);
 
-			return type;
+			return;
 		}
 
 		/// <summary>
@@ -2763,7 +2767,7 @@ void MarkGenericArguments (IGenericInstance instance)
 				var argument = arguments[i];
 				var parameter = parameters[i];
 
-				TypeDefinition? argumentTypeDef = MarkType (argument, new DependencyInfo (DependencyKind.GenericArgumentType, instance));
+				var argumentTypeDef = MarkType (argument, new DependencyInfo (DependencyKind.GenericArgumentType, instance), ScopeStack.CurrentScope.Origin);
 
 				if (Annotations.FlowAnnotations.RequiresGenericArgumentDataFlowAnalysis (parameter)) {
 					// The only two implementations of IGenericInstance both derive from MemberReference
@@ -2777,7 +2781,7 @@ void MarkGenericArguments (IGenericInstance instance)
 				if (argumentTypeDef == null)
 					continue;
 
-				Annotations.MarkRelevantToVariantCasting (argumentTypeDef);
+				_dependencyGraph.AddRoot (_nodeFactory.GetTypeIsRelevantToVariantCastingNode (argumentTypeDef), "Generic Argument");
 
 				if (parameter.HasDefaultConstructorConstraint)
 					MarkDefaultConstructor (argumentTypeDef, new DependencyInfo (DependencyKind.DefaultCtorForNewConstrainedGenericArgument, instance));
@@ -3030,7 +3034,8 @@ void MarkMethodCollection (IList<MethodDefinition> methods, in DependencyInfo re
 
 			// We will only enqueue a method to be processed if it hasn't been processed yet.
 			if (!CheckProcessed (method))
-				EnqueueMethod (method, reason, origin);
+				_completed = false;
+			_dependencyGraph.AddRoot (_nodeFactory.GetMethodDefinitionNode (method, reason), Enum.GetName (reason.Kind));
 
 			return method;
 		}
@@ -3161,14 +3166,13 @@ internal static void ReportRequiresUnreferencedCode (string displayName, Require
 			return (method, reason);
 		}
 
-		protected virtual void ProcessMethod (MethodDefinition method, in DependencyInfo reason, in MessageOrigin origin)
+		protected virtual void ProcessMethod (MethodDefinition method, in DependencyInfo reason)
 		{
 #if DEBUG
 			if (!_methodReasons.Contains (reason.Kind))
 				throw new InternalErrorException ($"Unsupported method dependency {reason.Kind}");
 #endif
 			ScopeStack.AssertIsEmpty ();
-			using var parentScope = ScopeStack.PushLocalScope (new MarkScopeStack.Scope (origin));
 			using var methodScope = ScopeStack.PushLocalScope (new MessageOrigin (method));
 
 			bool markedForCall =
@@ -3434,7 +3438,7 @@ void MarkBaseMethods (MethodDefinition method)
 				return;
 
 			foreach (OverrideInformation ov in base_methods) {
-				// We should add all interface base methods to _virtual_methods for virtual override annotation validation
+				// We should add all interface base methods to _interface_methods for virtual override annotation validation
 				// Interfaces from preserved scope will be missed if we don't add them here
 				// This will produce warnings for all interface methods and virtual methods regardless of whether the interface, interface implementation, or interface method is kept or not.
 				if (ov.Base.DeclaringType.IsInterface && !method.DeclaringType.IsInterface) {
diff --git a/src/tools/illink/src/linker/Linker/DictionaryExtensions.cs b/src/tools/illink/src/linker/Linker/DictionaryExtensions.cs
index 9cf8945fe480c..470cf9eb182ad 100644
--- a/src/tools/illink/src/linker/Linker/DictionaryExtensions.cs
+++ b/src/tools/illink/src/linker/Linker/DictionaryExtensions.cs
@@ -1,6 +1,7 @@
 // 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;
 
 namespace Mono.Linker
@@ -16,5 +17,15 @@ public static void AddToList<TKey, TElement> (this Dictionary<TKey, List<TElemen
 			}
 			valueList.Add (value);
 		}
+
+		public static U GetOrAdd<T, U> (this Dictionary<T, U> dict, T key, Func<T, U> createValue) where T : notnull
+		{
+			if (dict.TryGetValue (key, out var value)) {
+				return value;
+			}
+			U val = createValue (key);
+			dict.Add (key, val);
+			return val;
+		}
 	}
 }
diff --git a/src/tools/illink/src/linker/Mono.Linker.csproj b/src/tools/illink/src/linker/Mono.Linker.csproj
index f19ff4063e68c..24c4eba87ef35 100644
--- a/src/tools/illink/src/linker/Mono.Linker.csproj
+++ b/src/tools/illink/src/linker/Mono.Linker.csproj
@@ -76,6 +76,10 @@
     <Compile Include="..\..\external\corert\**\*.cs" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.DependencyAnalysisFramework\ILCompiler.DependencyAnalysisFramework.csproj" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Condition="'$(DotNetBuildSourceOnly)' != 'true'" Include="StaticCs" Version="$(StaticCsVersion)">
       <PrivateAssets>all</PrivateAssets>