diff --git a/eng/Versions.props b/eng/Versions.props
index ea29c2eae231..cef1af03cc2b 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -25,6 +25,7 @@
     <MicrosoftNetCompilersToolsetVersion>$(MicrosoftCodeAnalysisVersion)</MicrosoftNetCompilersToolsetVersion>
     <MicrosoftCodeAnalysisCSharpAnalyzerTestingXunitVersion>1.0.1-beta1.*</MicrosoftCodeAnalysisCSharpAnalyzerTestingXunitVersion>
     <MicrosoftCodeAnalysisBannedApiAnalyzersVersion>3.3.2</MicrosoftCodeAnalysisBannedApiAnalyzersVersion>
+    <MicrosoftILVerificationVersion>7.0.0-preview.7.22375.6</MicrosoftILVerificationVersion>
     <!-- This controls the version of the cecil package, or the version of cecil in the project graph
          when we build the cecil submodule. The reference assembly package will depend on this version of cecil.
          Keep this in sync with ProjectInfo.cs in the submodule. -->
diff --git a/external/cecil b/external/cecil
index 2cd569a98964..1840b7410d37 160000
--- a/external/cecil
+++ b/external/cecil
@@ -1 +1 @@
-Subproject commit 2cd569a98964629b8fa88284a8b5af8077d5f9de
+Subproject commit 1840b7410d37a613e684b6f9650e39e2d4950bbb
diff --git a/src/ILLink.RoslynAnalyzer/RequiresISymbolExtensions.cs b/src/ILLink.RoslynAnalyzer/RequiresISymbolExtensions.cs
index f47097cc475d..c4504332e9b9 100644
--- a/src/ILLink.RoslynAnalyzer/RequiresISymbolExtensions.cs
+++ b/src/ILLink.RoslynAnalyzer/RequiresISymbolExtensions.cs
@@ -72,6 +72,15 @@ private static bool IsInRequiresScope (this ISymbol member, string requiresAttri
 			if (checkAssociatedSymbol && member is IMethodSymbol { AssociatedSymbol: { } associated } && associated.HasAttribute (requiresAttribute))
 				return true;
 
+			// When using instance fields suppress the warning if the constructor has already the Requires annotation
+			if (member is IFieldSymbol field && !field.IsStatic) {
+				foreach (var constructor in field.ContainingType.InstanceConstructors) {
+					if (!constructor.HasAttribute (requiresAttribute))
+						return false;
+				}
+				return true;
+			}
+
 			return false;
 		}
 	}
diff --git a/src/linker/Linker.Steps/MarkStep.cs b/src/linker/Linker.Steps/MarkStep.cs
index 66733c12a402..81b4b5909001 100644
--- a/src/linker/Linker.Steps/MarkStep.cs
+++ b/src/linker/Linker.Steps/MarkStep.cs
@@ -59,7 +59,7 @@ protected LinkContext Context {
 		}
 
 		protected Queue<(MethodDefinition, DependencyInfo, MessageOrigin)> _methods;
-		protected List<(MethodDefinition, MarkScopeStack.Scope)> _virtual_methods;
+		protected HashSet<(MethodDefinition, MarkScopeStack.Scope)> _virtual_methods;
 		protected Queue<AttributeProviderPair> _assemblyLevelAttributes;
 		readonly List<AttributeProviderPair> _ivt_attributes;
 		protected Queue<(AttributeProviderPair, DependencyInfo, MarkScopeStack.Scope)> _lateMarkedAttributes;
@@ -224,7 +224,7 @@ internal DynamicallyAccessedMembersTypeHierarchy DynamicallyAccessedMembersTypeH
 		public MarkStep ()
 		{
 			_methods = new Queue<(MethodDefinition, DependencyInfo, MessageOrigin)> ();
-			_virtual_methods = new List<(MethodDefinition, MarkScopeStack.Scope)> ();
+			_virtual_methods = new HashSet<(MethodDefinition, MarkScopeStack.Scope)> ();
 			_assemblyLevelAttributes = new Queue<AttributeProviderPair> ();
 			_ivt_attributes = new List<AttributeProviderPair> ();
 			_lateMarkedAttributes = new Queue<(AttributeProviderPair, DependencyInfo, MarkScopeStack.Scope)> ();
@@ -3352,7 +3352,6 @@ void MarkBaseMethods (MethodDefinition method)
 				if (base_method.DeclaringType.IsInterface && !method.DeclaringType.IsInterface) {
 					// These are all virtual, no need to check IsVirtual before adding to list
 					_virtual_methods.Add ((base_method, ScopeStack.CurrentScope));
-					// _virtual_methods is a list and might have duplicates, but it's mostly just used for override validation, so it shouldn't matter
 					continue;
 				}
 
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/GenericAttributes.cs b/test/Mono.Linker.Tests.Cases/Attributes/GenericAttributes.cs
new file mode 100644
index 000000000000..430fbc71417d
--- /dev/null
+++ b/test/Mono.Linker.Tests.Cases/Attributes/GenericAttributes.cs
@@ -0,0 +1,69 @@
+using System;
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+using Mono.Linker.Tests.Cases.Expectations.Metadata;
+
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	class GenericAttributes
+	{
+        static void Main ()
+        {
+            new WithGenericAttribute_OfString ();
+            new WithGenericAttribute_OfInt ();
+            new WithConstrainedGenericAttribute ();
+        }
+
+        [Kept]
+        [KeptAttributeAttribute (typeof (GenericAttribute<string>))]
+        [KeptMember (".ctor()")]
+        [GenericAttribute<string>("t", F = "f", P = "p")]
+        class WithGenericAttribute_OfString {
+        }
+
+        [Kept]
+        [KeptAttributeAttribute (typeof (GenericAttribute<int>))]
+        [KeptMember (".ctor()")]
+        [GenericAttribute<int>(1, F = 2, P = 3)]
+        class WithGenericAttribute_OfInt {
+        }
+
+        [Kept]
+        [KeptAttributeAttribute (typeof (ConstrainedGenericAttribute<DerivedFromConstraintType>))]
+        [KeptMember (".ctor()")]
+        [ConstrainedGenericAttribute<DerivedFromConstraintType>()]
+        class WithConstrainedGenericAttribute {
+        }
+
+        [KeptBaseType (typeof (Attribute))]
+        class GenericAttribute<T> : Attribute {
+            [Kept]
+            public GenericAttribute(T t) {}
+
+            [Kept]
+            public T F;
+
+            [Kept]
+            [KeptBackingField]
+            public T P {
+                get;
+                [Kept]
+                set;
+            }
+        }
+
+        [Kept]
+        class ConstraintType {
+        }
+
+        [KeptBaseType (typeof (ConstraintType))]
+        class DerivedFromConstraintType : ConstraintType {
+        }
+
+        [KeptBaseType (typeof (Attribute))]
+        class ConstrainedGenericAttribute<T> : Attribute
+            where T : ConstraintType {
+            [Kept]
+            public ConstrainedGenericAttribute() {}
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs
index 262e9b3f72b4..9e4df4cbcc51 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs
@@ -351,6 +351,7 @@ public static void Test ()
 
 				TestWithMultipleArgumentsWithRequirements ();
 
+				StaticInterfaceMethods.Test ();
 				NewConstraint.Test ();
 				StructConstraint.Test ();
 				UnmanagedConstraint.Test ();
@@ -631,7 +632,6 @@ static void TestWithRequirementsFromGenericParam<
 					.MakeGenericMethod (typeof (T));
 			}
 
-
 			static void TestWithRequirementsViaRuntimeMethod ()
 			{
 				typeof (MakeGenericMethod).GetRuntimeMethod (nameof (GenericWithRequirements), Type.EmptyTypes)
@@ -750,6 +750,36 @@ static void GenericWithMultipleArgumentsWithRequirements<
 			{
 			}
 
+			class StaticInterfaceMethods
+			{
+				public static void Test ()
+				{
+					KnownType ();
+					UnannotatedGenericParam<int> ();
+					AnnotatedGenericParam<int> ();
+				}
+
+				static MethodInfo KnownType ()
+					=> typeof (IFoo).GetMethod ("Method")
+					.MakeGenericMethod (new Type[] { typeof (int) });
+
+				[ExpectedWarning ("IL2090", "T", "PublicMethods")]
+				static MethodInfo UnannotatedGenericParam<T> ()
+					=> typeof (IFoo).GetMethod ("Method")
+					.MakeGenericMethod (new Type[] { typeof (T) });
+
+				static MethodInfo AnnotatedGenericParam<
+					[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] T> ()
+					=> typeof (IFoo).GetMethod ("Method")
+					.MakeGenericMethod (new Type[] { typeof (T) });
+
+				interface IFoo
+				{
+					static abstract T Method<
+						[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] T> ();
+				}
+			}
+
 			class NewConstraint
 			{
 				static void GenericWithNewConstraint<T> () where T : new()
diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs
index a0ecc2e51a81..44de82e7f7c9 100644
--- a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs
+++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs
@@ -25,6 +25,7 @@ public static void Main ()
 			TestRequiresOnBaseButNotOnDerived ();
 			TestRequiresOnDerivedButNotOnBase ();
 			TestRequiresOnBaseAndDerived ();
+			TestInstanceFieldSuppression ();
 			TestSuppressionsOnClass ();
 			TestStaticMethodOnRequiresTypeSuppressedByRequiresOnMethod ();
 			TestStaticConstructorCalls ();
@@ -246,6 +247,22 @@ static void TestInstanceFieldCallDontWarn ()
 			var _ = instance.field;
 		}
 
+		public class ClassWithInstanceFieldWhichInitsDangerousClass
+		{
+			private ClassWithRequires _instanceField = new ClassWithRequires ();
+
+			[RequiresUnreferencedCode ("Calling the constructor is dangerous")]
+			[RequiresDynamicCode ("Calling the constructor is dangerous")]
+			public ClassWithInstanceFieldWhichInitsDangerousClass () { }
+		}
+
+		[ExpectedWarning ("IL2026", "Calling the constructor is dangerous")]
+		[ExpectedWarning ("IL3050", "Calling the constructor is dangerous", ProducedBy = ProducedBy.Analyzer)]
+		static void TestInstanceFieldSuppression ()
+		{
+			_ = new ClassWithInstanceFieldWhichInitsDangerousClass ();
+		}
+
 		[RequiresUnreferencedCode ("Message for --StaticCtorTriggeredByMethodCall2--")]
 		[RequiresDynamicCode ("Message for --StaticCtorTriggeredByMethodCall2--")]
 		class StaticCtorTriggeredByMethodCall2
diff --git a/test/Mono.Linker.Tests/Mono.Linker.Tests.csproj b/test/Mono.Linker.Tests/Mono.Linker.Tests.csproj
index 4a9ea7e7f2ce..448601a8a643 100644
--- a/test/Mono.Linker.Tests/Mono.Linker.Tests.csproj
+++ b/test/Mono.Linker.Tests/Mono.Linker.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -32,6 +32,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="$(MicrosoftCodeAnalysisVersion)" />
+    <PackageReference Include="Microsoft.ILVerification" Version="$(MicrosoftILVerificationVersion)" />
     <PackageReference Include="nunit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <!-- This reference is purely so that the linker can resolve this
diff --git a/test/Mono.Linker.Tests/TestCasesRunner/ILVerifier.cs b/test/Mono.Linker.Tests/TestCasesRunner/ILVerifier.cs
new file mode 100644
index 000000000000..bf935cc22067
--- /dev/null
+++ b/test/Mono.Linker.Tests/TestCasesRunner/ILVerifier.cs
@@ -0,0 +1,132 @@
+// 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 System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.PortableExecutable;
+using System.Runtime.Loader;
+using ILVerify;
+using Mono.Linker.Tests.Extensions;
+
+#nullable enable
+namespace Mono.Linker.Tests.TestCasesRunner
+{
+	class ILVerifier : ILVerify.IResolver
+	{
+		Verifier _verifier;
+		NPath _assemblyFolder;
+		NPath _frameworkFolder;
+		Dictionary<string, PEReader> _assemblyCache;
+		AssemblyLoadContext _alc;
+
+		public IEnumerable<VerificationResult> Results { get; private set; }
+
+		public ILVerifier (NPath assemblyPath)
+		{
+			var assemblyName = assemblyPath.FileNameWithoutExtension;
+			_assemblyFolder = assemblyPath.Parent;
+			_assemblyCache = new Dictionary<string, PEReader> ();
+			_frameworkFolder = typeof (object).Assembly.Location.ToNPath ().Parent;
+			_alc = new AssemblyLoadContext (_assemblyFolder.FileName);
+			LoadAssembly ("mscorlib");
+			LoadAssembly ("System.Private.CoreLib");
+			LoadAssemblyFromPath (assemblyName, assemblyPath);
+
+			_verifier = new ILVerify.Verifier (
+				this,
+				new ILVerify.VerifierOptions {
+					SanityChecks = true,
+					IncludeMetadataTokensInErrorMessages = true
+				});
+			_verifier.SetSystemModuleName (new AssemblyName ("mscorlib"));
+
+			var allResults = _verifier.Verify (Resolve (assemblyName))
+				?? Enumerable.Empty<VerificationResult> ();
+
+			Results = allResults.Where (r => r.Code switch {
+				ILVerify.VerifierError.None
+				// Static interface methods cause this warning
+				or ILVerify.VerifierError.CallAbstract
+				// "Missing callVirt after constrained prefix - static interface methods cause this warning
+				or ILVerify.VerifierError.Constrained
+				// ex. localloc cannot be statically verified by ILVerify
+				or ILVerify.VerifierError.Unverifiable
+				// ref returning a ref local causes this warning but is okay
+				or VerifierError.ReturnPtrToStack
+				// Span indexing with indexer (ex. span[^4]) causes this warning
+				or VerifierError.InitOnly
+				=> false,
+				_ => true
+			});
+		}
+
+		PEReader LoadAssembly (string assemblyName)
+		{
+			if (_assemblyCache.TryGetValue (assemblyName, out PEReader? reader))
+				return reader;
+			var assembly = _alc.LoadFromAssemblyName (new AssemblyName (assemblyName));
+			reader = new PEReader (File.OpenRead (assembly.Location));
+			_assemblyCache.Add (assemblyName, reader);
+			return reader;
+		}
+
+		PEReader LoadAssemblyFromPath (string assemblyName, NPath pathToAssembly)
+		{
+			if (_assemblyCache.TryGetValue (assemblyName, out PEReader? reader))
+				return reader;
+			var assembly = _alc.LoadFromAssemblyPath (pathToAssembly);
+			reader = new PEReader (File.OpenRead (assembly.Location));
+			_assemblyCache.Add (assemblyName, reader);
+			return reader;
+		}
+
+		bool TryLoadAssemblyFromFolder (string assemblyName, NPath folder, [NotNullWhen (true)] out PEReader? peReader)
+		{
+			Assembly? assembly = null;
+			string assemblyPath = Path.Join (folder.ToString (), assemblyName);
+			if (File.Exists (assemblyPath + ".dll"))
+				assembly = _alc.LoadFromAssemblyPath (assemblyPath + ".dll");
+			else if (File.Exists (assemblyPath + ".exe"))
+				assembly = _alc.LoadFromAssemblyPath (assemblyPath + ".exe");
+
+			if (assembly is not null) {
+				peReader = new PEReader (File.OpenRead (assembly.Location));
+				_assemblyCache.Add (assemblyName, peReader);
+				return true;
+			}
+			peReader = null;
+			return false;
+		}
+
+		PEReader? Resolve (string assemblyName)
+		{
+			PEReader? reader;
+			if (_assemblyCache.TryGetValue (assemblyName, out reader)) {
+				return reader;
+			}
+
+			if (TryLoadAssemblyFromFolder (assemblyName, _frameworkFolder, out reader))
+				return reader;
+
+			if (TryLoadAssemblyFromFolder (assemblyName, _assemblyFolder, out reader))
+				return reader;
+
+			return null;
+		}
+
+		PEReader? ILVerify.IResolver.ResolveAssembly (AssemblyName assemblyName)
+			=> Resolve (assemblyName.Name ?? assemblyName.FullName);
+
+		PEReader? ILVerify.IResolver.ResolveModule (AssemblyName referencingModule, string fileName)
+			=> Resolve (Path.GetFileNameWithoutExtension (fileName));
+
+		public string GetErrorMessage (VerificationResult result)
+		{
+			return $"IL Verification error:\n{result.Message}";
+		}
+	}
+}
+#nullable restore
diff --git a/test/Mono.Linker.Tests/TestCasesRunner/ResultChecker.cs b/test/Mono.Linker.Tests/TestCasesRunner/ResultChecker.cs
index bd611721cd60..ccb76575ff41 100644
--- a/test/Mono.Linker.Tests/TestCasesRunner/ResultChecker.cs
+++ b/test/Mono.Linker.Tests/TestCasesRunner/ResultChecker.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -13,6 +14,7 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Extensions;
 using NUnit.Framework;
+using WellKnownType = ILLink.Shared.TypeSystemProxy.WellKnownType;
 
 namespace Mono.Linker.Tests.TestCasesRunner
 {
@@ -47,6 +49,32 @@ public ResultChecker (BaseAssemblyResolver originalsResolver, BaseAssemblyResolv
 			_linkedReaderParameters = linkedReaderParameters;
 		}
 
+		static void VerifyIL (NPath pathToAssembly)
+		{
+			var verifier = new ILVerifier (pathToAssembly);
+			foreach (var result in verifier.Results) {
+				if (result.Code == ILVerify.VerifierError.None)
+					continue;
+				Assert.Fail (verifier.GetErrorMessage (result));
+			}
+		}
+
+		static bool ShouldValidateIL (AssemblyDefinition inputAssembly)
+		{
+			if (HasAttribute (inputAssembly, nameof (SkipPeVerifyAttribute)))
+				return false;
+
+			var caaIsUnsafeFlag = (CustomAttributeArgument caa) =>
+				caa.Type.IsTypeOf (WellKnownType.System_String)
+				&& (string) caa.Value == "/unsafe";
+			var customAttributeHasUnsafeFlag = (CustomAttribute ca) => ca.ConstructorArguments.Any (caaIsUnsafeFlag);
+			if (GetCustomAttributes (inputAssembly, nameof (SetupCompileArgumentAttribute))
+				.Any (customAttributeHasUnsafeFlag))
+				return false;
+
+			return true;
+		}
+
 		public virtual void Check (LinkedTestCaseResult linkResult)
 		{
 			InitializeResolvers (linkResult);
@@ -57,6 +85,9 @@ public virtual void Check (LinkedTestCaseResult linkResult)
 					Assert.IsTrue (linkResult.OutputAssemblyPath.FileExists (), $"The linked output assembly was not found.  Expected at {linkResult.OutputAssemblyPath}");
 					var linked = ResolveLinkedAssembly (linkResult.OutputAssemblyPath.FileNameWithoutExtension);
 
+					if (ShouldValidateIL (original))
+						VerifyIL (linkResult.OutputAssemblyPath);
+
 					InitialChecking (linkResult, original, linked);
 
 					PerformOutputAssemblyChecks (original, linkResult.OutputAssemblyPath.Parent);
@@ -1069,15 +1100,40 @@ bool IsTypeInOtherAssemblyAssertion (CustomAttribute attr)
 		}
 
 		static bool HasAttribute (ICustomAttributeProvider caProvider, string attributeName)
+		{
+			return TryGetCustomAttribute (caProvider, attributeName, out var _);
+		}
+
+#nullable enable
+		static bool TryGetCustomAttribute (ICustomAttributeProvider caProvider, string attributeName, [NotNullWhen (true)] out CustomAttribute? customAttribute)
+		{
+			if (caProvider is AssemblyDefinition assembly && assembly.EntryPoint != null) {
+				customAttribute = assembly.EntryPoint.DeclaringType.CustomAttributes
+					.FirstOrDefault (attr => attr!.AttributeType.Name == attributeName, null);
+				return customAttribute is not null;
+			}
+
+			if (caProvider is TypeDefinition type) {
+				customAttribute = type.CustomAttributes
+					.FirstOrDefault (attr => attr!.AttributeType.Name == attributeName, null);
+				return customAttribute is not null;
+			}
+			customAttribute = null;
+			return false;
+		}
+
+		static IEnumerable<CustomAttribute> GetCustomAttributes (ICustomAttributeProvider caProvider, string attributeName )
 		{
 			if (caProvider is AssemblyDefinition assembly && assembly.EntryPoint != null)
 				return assembly.EntryPoint.DeclaringType.CustomAttributes
-					.Any (attr => attr.AttributeType.Name == attributeName);
+					.Where (attr => attr!.AttributeType.Name == attributeName);
 
 			if (caProvider is TypeDefinition type)
-				return type.CustomAttributes.Any (attr => attr.AttributeType.Name == attributeName);
+				return type.CustomAttributes
+					.Where (attr => attr!.AttributeType.Name == attributeName);
 
-			return false;
+			return Enumerable.Empty<CustomAttribute> ();
 		}
+#nullable restore
 	}
 }